Buffers going through a data flow

Table with quite large columns

DefaultBufferSize 64KB <> 100MB

360 rows = ±10MB

721 rows = ± 20MB

Use query instead of whole table

Removing unwanted columns => more rows in buffer

Resizing datatypes => more rows in buffer

Uncheck and check changed columns

Add WHERE clause instead of Conditional Split

RunInOptimizedMode

• Rows in buffer type 0 would cause a buffer size greater than the configured maximum. There will be only 787 rows in buffers of this type.
• Rows in buffer type 0 would cause a buffer size greater than the configured maximum. There will be only 1538 rows in buffers of this type.

• The default buffer size is 10485760 bytes.
• Buffers will have 10000 rows by default.
• The data flow will not remove unused components because its RunInOptimizedMode property is set to false.

BufferSizeTuning and PipelineInitialization

Very very basic enumerator example, but it works

Two project for my enumerator solution

Microsoft (R) .NET Framework Strong Name Utility

Add key to projects

Sign Assembly

• Microsoft.SqlServer.Dts.Design
• Microsoft.SQLServer.ManagedDTS

• Microsoft.SQLServer.ManagedDTS

Add references

Post-Build Events

Two properties: folder and wildcard filter

// C# code
// The code-behind from our GUI.
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Microsoft.SqlServer.Dts.Runtime; // Added

namespace SSISJoost
{
    public partial class myEnumeratorEditor : ForEachEnumeratorUI
    {
        // Variables needed to communicate with SSIS.
        // You could for example get a list of all
        // variables or connection managers.
        private ForEachEnumeratorHost _feeHost;
        private Connections _connections;   // not used in this solution
        private Variables _variables;       // not used in this solution

        // Constructor
        public myEnumeratorEditor()
        {
            InitializeComponent();
        }

        // This method is executed when you open the editor.
        public override void Initialize(ForEachEnumeratorHost FEEHost, IServiceProvider serviceProvider, Connections connections, Variables variables)
        {
            // Filling those variables so that we read values of two properties
            base.Initialize(FEEHost, serviceProvider, connections, variables);
            this._feeHost = FEEHost;
            this._connections = connections;    // not used in this solution
            this._variables = variables;        // not used in this solution

            // Get the properties from the Enumerator. I have added these properties in the 
            // other project. They are used to store the folder and filter in the package.
            if (this._feeHost != null)
            {
                // Get the Directory value and fill the textbox.
                if (this._feeHost.Properties["Directory"] != null)
                {
                    this.txtFolder.Text = (string)this._feeHost.Properties["Directory"].GetValue(_feeHost);
                }
                // Get the Filter value and fill the textbox.
                if (this._feeHost.Properties["Filter"] != null)
                {
                    this.txtFilter.Text = (string)this._feeHost.Properties["Filter"].GetValue(_feeHost);
                }
            }
        }

        // This method is execute when you press OK in the editor
        public override void SaveSettings()
        {
            base.SaveSettings();
            // When you close(/save) the enumerator then you need to write the values from the 
            // form to the properties of the enumerator so that they are saved in the package.
            this._feeHost.Properties["Directory"].SetValue(this._feeHost, this.txtFolder.Text);
            this._feeHost.Properties["Filter"].SetValue(this._feeHost, this.txtFilter.Text);
        }

        // Open browse folder dialog when you click the button
        private void btnBrowse_Click(object sender, EventArgs e)
        {
            if (DialogResult.OK == folderBrowserDialog.ShowDialog())
            {
                txtFolder.Text = folderBrowserDialog.SelectedPath;
            }
        }
    }
}

Copy the number generated. You need it in the next project.

// C# code
// The code from the project that does the actual work.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SqlServer.Dts.Runtime;              // Added
using Microsoft.SqlServer.Dts.Runtime.Enumerators;  // Added
using System.IO;                                    // Added

namespace SSISJoost
{
    // Connection to the editor assembly. Copy the PublicKeyToken from the previous step.
    [DtsForEachEnumerator(
           DisplayName = "myEnumerator",
           Description = "A very basic enumerator",
           UITypeName = "SSISJoost.myEnumeratorEditor, SSISJoost.myEnumeratorUI, Version=1.0.0.0, Culture=Neutral,PublicKeyToken=629e0ff8812f1e93")]
    public class myEnumerator : ForEachEnumerator
    {
        // The properties of my enumerator that will
        // be saved in the xml of the SSIS package.

        // A property for the folder
        private string _directory;
        public string Directory
        {
            get { return this._directory; }
            set { this._directory = value; }
        }

        // A property for the wildcard filter
        private string _filter = "*.*";
        public string Filter
        {
            get { return this._filter; }
            set { this._filter = value; }
        }

        // This validation method is execute when you run the package, but also when
        // you click OK in the editor. You can fire warnings and errors.
        public override DTSExecResult Validate(Connections connections, VariableDispenser variableDispenser, IDTSInfoEvents infoEvents, IDTSLogging log)
        {
            // Directory is mandatory 
            if (string.IsNullOrEmpty(_directory))
            {
                // Fire error and fail package
                infoEvents.FireError(0, "myEnumerator", "Directory is mandatory", "", 0);
                return DTSExecResult.Failure;
            }

            // Filter isn't mandatory, but fire warning that a default will be used
            if (string.IsNullOrEmpty(_filter))
            {
                // Fire warming, but continue
                infoEvents.FireWarning(0, "myEnumerator", "Filter is empty. The default *.* will be used.", "", 0);
            }
            return DTSExecResult.Success;
        }

        // This is the method that fills the enumerator.
        // You can enumerate through just about anything
        // you like. This is a simplified file enumerator.
        public override object GetEnumerator(Connections connections, VariableDispenser variableDispenser, IDTSInfoEvents events, IDTSLogging log)
        {
            // Determine the options for getting the files
            string startFolder = this._directory;
            string filter = "*.*";
            System.IO.SearchOption searchOption = SearchOption.TopDirectoryOnly;

            // If the filter is "", then just use the "*.*" as default
            if (!string.IsNullOrEmpty(this._filter))
            {
                filter = this._filter;
            }

            // Create a list that will be returned by this method
            List<String> filePaths = new List<String>(); ;

            try
            {
                // Take a snapshot of the file system.
                System.IO.DirectoryInfo dir = new System.IO.DirectoryInfo(startFolder);

                // Get all the files that match the critery
                IQueryable<System.IO.FileInfo> fileList = dir.GetFiles(filter, searchOption).AsQueryable<System.IO.FileInfo>();

                // Loop through list and only get the 'Fully Qualified Name' => the complete path
                foreach (FileInfo myFile in fileList)
                {
                    filePaths.Add(myFile.FullName);
                }
            }
            catch (Exception ex)
            {
                // Fire error if something unexpected fails
                events.FireError(0, "myEnumerator", "Unexpected Exception: " + ex.Message, "", 0);
            }

            // return the list
            return filePaths.GetEnumerator();
        }
    }
}

New enumerator in action

My first SSIS task

Two projects for my Task

Microsoft (R) .NET Framework Strong Name Utility

Add key to projects

Sign Assembly

• Microsoft.SqlServer.Dts.Design
• Microsoft.SQLServer.ManagedDTS

• Microsoft.SQLServer.ManagedDTS

Add references

Post-build events

Icon for editor

Icon for SSIS Toolbox and Control Flow

// C# code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SqlServer.Dts.Runtime;
using Microsoft.SqlServer.Dts.Runtime.Design;
using System.Windows.Forms;

// Interface for task editor
namespace SSISJoost
{
    public class myTaskInterface : IDtsTaskUI
    {
        private TaskHost _taskHost;
        private IServiceProvider _serviceProvider;

        public myTaskInterface()
        {
        }

        public void Initialize(TaskHost taskHost, IServiceProvider serviceProvider)
        {
            this._taskHost = taskHost;
            this._serviceProvider = serviceProvider;
        }

        public ContainerControl GetView()
        {
            myTaskUI.myTaskEditor editor = new myTaskUI.myTaskEditor();
            editor.TaskHost = this._taskHost;
            editor.ServiceProvider = this._serviceProvider;
            return editor;
        }

        public void Delete(IWin32Window parentWindow)
        {
        }

        public void New(IWin32Window parentWindow)
        {
        }
    }
}

// C# code
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing; // Reference added
using System.Linq;
using System.Text;
using System.Windows.Forms; // Reference added
using Microsoft.SqlServer.Dts.Runtime;
using Microsoft.SqlServer.Dts.Runtime.Design;

namespace SSISJoost.myTaskUI
{
    public partial class myTaskEditor : Form
    {
        #region General Task Methods
        // Setting and getting taskhost
        private TaskHost _taskHost;
        public TaskHost TaskHost
        {
            get { return _taskHost; }
            set { _taskHost = value; }
        }

        // Getting connections, setting is done with ServiceProvider
        private Connections _connections;
        public Connections connections
        {
            get { return _connections; }
        }

        // Gets or sets the serviceprovider. Used for getting
        // f.a. the VariablesProvider and ConnectionsProvider
        private IServiceProvider _serviceProvider = null;
        public IServiceProvider ServiceProvider
        {
            get
            {
                return _serviceProvider;
            }
            set
            {
                _serviceProvider = value;
                _connections = ((IDtsConnectionService)(value.GetService(typeof(IDtsConnectionService)))).GetConnections();
            }
        }

        // Default constructor
        public myTaskEditor()
        {
            InitializeComponent();
        }

        // Constructor to set taskhost and serviceprovider
        // See GetView in myTaskInterface.cs
        public myTaskEditor(TaskHost taskHost, IServiceProvider serviceprovider)
        {
            InitializeComponent();

            this.TaskHost = taskHost;
            this.ServiceProvider = serviceprovider;
        }
        #endregion

        #region Page Load
        private void myTaskEditor_Load(object sender, EventArgs e)
        {
            // Fill the ComboBox with connection managers from the package,
            // but only select FILE, FLATFILE and EXCEL connection managers.
            if (this._taskHost != null && this._connections != null)
            {
                cmbConnectionsSource.Items.Clear();
                cmbConnectionsSource.DisplayMember = "Name";
                cmbConnectionsSource.ValueMember = "ID";
                cmbConnectionsSource.Items.Add("<Choose connectionmanager>");
                cmbConnectionsSource.Items.Add("<New connectionmanager>");  // open new connection manager popup
                foreach (ConnectionManager connection in this._connections)
                {
                    if (connection.CreationName == "FILE")
                    {
                        cmbConnectionsSource.Items.Add(connection);
                    }
                    else if (connection.CreationName == "EXCEL")
                    {
                        cmbConnectionsSource.Items.Add(connection);
                    }
                    else if (connection.CreationName == "FLATFILE")
                    {
                        cmbConnectionsSource.Items.Add(connection);
                    }
                }
            }

            // Fill the ComboBox with variables from the package,
            // but only show string variables and non-system variables
            if (this._taskHost != null && this._taskHost.Variables != null)
            {
                cmbVariablesSource.Items.Clear();
                cmbVariablesSource.DisplayMember = "Name";
                cmbVariablesSource.ValueMember = "QualifiedName";
                cmbVariablesSource.Items.Add("<Choose variable>");
                cmbVariablesSource.Items.Add("<New variable>");  // open new variabele popup
                foreach (Variable variable in _taskHost.Variables)
                {
                    if ((!variable.SystemVariable) && (variable.DataType == TypeCode.String))
                    {
                        this.cmbVariablesSource.Items.Add(variable);
                    }
                }
            }


            // Get the properties from the Task and fill the form.
            if (this._taskHost != null)
            {
                // Only fill form if a value is found in the properties
                if (this._taskHost.Properties["HasConnectionmanagerSource"] != null)
                {
                    // A connection manager is selected
                    if ((bool)this._taskHost.Properties["HasConnectionmanagerSource"].GetValue(_taskHost))
                    {
                        this.radConnectionSource.Checked = true;
                        this.cmbConnectionsSource.Enabled = true;
                        this.cmbVariablesSource.Enabled = false;
                        this.cmbVariablesSource.SelectedIndex = 0;
                        // Set the ConnectionManagerID
                        if (this._taskHost.Properties["SelectedConnectionManagerIDSource"] != null)
                        {
                            object obj = this._taskHost.Properties["SelectedConnectionManagerIDSource"].GetValue(_taskHost);
                            if (obj == null)
                            {
                                // No connection manager in property
                                this.cmbConnectionsSource.SelectedIndex = 0;
                            }
                            else
                            {
                                ConnectionManager cm = null;
                                cm = FindConnectionManager(obj.ToString().Trim());
                                if (cm != null)
                                {
                                    // Connection manager found, now select it in combobox
                                    this.cmbConnectionsSource.SelectedItem = cm;
                                }
                                else
                                {
                                    // Connection manager not found
                                    this.cmbConnectionsSource.SelectedIndex = 0;
                                }
                            }
                        }
                    }
                    // A variable is selected
                    else
                    {
                        this.radVariableSource.Checked = true;
                        this.cmbVariablesSource.Enabled = true;
                        this.cmbConnectionsSource.Enabled = false;
                        this.cmbConnectionsSource.SelectedIndex = 0;
                        // Set the VariableID
                        if (this._taskHost.Properties["SelectedVariableIDSource"] != null)
                        {
                            object obj = this._taskHost.Properties["SelectedVariableIDSource"].GetValue(_taskHost);
                            if (obj == null)
                            {
                                // No variable in property
                                this.cmbVariablesSource.SelectedIndex = 0;
                                return;
                            }
                            Variable var = FindVariable(this._taskHost.Properties["SelectedVariableIDSource"].GetValue(_taskHost).ToString().Trim());
                            if (var != null)
                            {
                                // Variable found, now select it in combobox
                                this.cmbVariablesSource.SelectedItem = var;
                            }
                            else
                            {
                                // Variable not found
                                this.cmbVariablesSource.SelectedIndex = 0;
                            }
                        }
                    }
                }
            }
            // Initial values (for new tasks)
            else
            {
                this.radConnectionSource.Checked = true;
                this.cmbConnectionsSource.Enabled = true;
                this.cmbConnectionsSource.SelectedIndex = 0;
                this.cmbVariablesSource.Enabled = false;
                this.cmbVariablesSource.SelectedIndex = 0;
            }
        }
        #endregion

        #region Button Methods OK end Cancel
        private void btnCancel_Click(object sender, EventArgs e)
        {
            // Cancel editor / close window
            this.DialogResult = DialogResult.Cancel;
            this.Close();
        }

        private void btnSave_Click(object sender, EventArgs e)
        {
            // Safe Source values (radiobutton, connectionmanager, variable) in tasks properties.
            // Selected Connection Manager or Variable is available via variables that where
            // filled by onchange events from the comboboxes.
            this._taskHost.Properties["HasConnectionmanagerSource"].SetValue(this._taskHost, radConnectionSource.Checked);
            if (radConnectionSource.Checked)
            {
                this._taskHost.Properties["SelectedVariableIDSource"].SetValue(this._taskHost, string.Empty);

                if (this.cmbConnectionsSource.SelectedIndex != 0)
                {
                    this._taskHost.Properties["SelectedConnectionManagerIDSource"].SetValue(this._taskHost, selectedConnectionManagerSource.ID);
                }
                else
                {
                    this._taskHost.Properties["SelectedConnectionManagerIDSource"].SetValue(this._taskHost, string.Empty);
                }
            }
            else
            {
                this._taskHost.Properties["SelectedConnectionManagerIDSource"].SetValue(this._taskHost, string.Empty);

                if (this.cmbVariablesSource.SelectedIndex != 0)
                {
                    this._taskHost.Properties["SelectedVariableIDSource"].SetValue(this._taskHost, selectedVariableSource.ID);
                }
                else
                {
                    this._taskHost.Properties["SelectedVariableIDSource"].SetValue(this._taskHost, string.Empty);
                }
            }

            // Close editor
            this.DialogResult = DialogResult.OK;
            this.Close();
        }
        #endregion

        #region Onchange events methods Comboboxes
        // Variable to store the selected connectionmanager. It will be filled by
        // the SelectedIndexChange event and used by the OK button click event.
        private ConnectionManager selectedConnectionManagerSource = null;

        // Method to set the selected connectionmanager
        private void cmbConnectionsSource_SelectedIndexChanged(object sender, EventArgs e)
        {
            ComboBox combobox = (ComboBox)sender;

            // If <Choose connectionmanager> is selected then empty the textbox with the path
            if (combobox.SelectedIndex == 0)
            {
                this.txtFilePathFinalSource.Text = "";
                return;
            }

            // If <New connectionmanager> is selected then popup to create a new connection manager
            if (combobox.SelectedIndex == 1)
            {
                int currentdIndex = -1;
                IDtsConnectionService _dtsConnectionService = _serviceProvider.GetService(typeof(IDtsConnectionService)) as IDtsConnectionService;
                System.Collections.ArrayList createdConnection = _dtsConnectionService.CreateConnection(Prompt.ShowConnectionManagerTypeDialog());
                if (createdConnection.Count > 0)
                {
                    ConnectionManager newConnectionManager = (ConnectionManager)createdConnection[0];
                    _dtsConnectionService.AddConnectionToPackage(newConnectionManager);
                    currentdIndex = combobox.Items.Add(newConnectionManager);
                    combobox.SelectedIndex = currentdIndex;
                    return;
                }
                else
                {
                    // Cancel was clicked in popup
                    combobox.SelectedIndex = 0;
                    return;
                }
            }

            // Fill the private variable to store the selected connectionmanager
            selectedConnectionManagerSource = (ConnectionManager)combobox.SelectedItem;

            // If the variable is still null then clear form
            if (selectedConnectionManagerSource == null)
            {
                this.cmbConnectionsSource.SelectedIndex = 0;
                this.txtFilePathFinalSource.Text = "";
                return;
            }

            // Get the path of the connectionmanager. For Excel connectionmanagers
            // you should use ExcelFilePath property instead of the connectionstring
            if (selectedConnectionManagerSource.CreationName == "EXCEL")
            {
                this.txtFilePathFinalSource.Text = selectedConnectionManagerSource.Properties["ExcelFilePath"].GetValue(selectedConnectionManagerSource).ToString();
            }
            else
            {
                this.txtFilePathFinalSource.Text = selectedConnectionManagerSource.ConnectionString;
            }
        }

        // Variable to store the selected variable. It will be filled by
        // the SelectedIndexChange event and used by the OK button click event.
        private Variable selectedVariableSource = null;

        // Method to set the selected variable
        private void cmbVariablesSource_SelectedIndexChanged(object sender, EventArgs e)
        {
            ComboBox combobox = (ComboBox)sender;

            // If <Choose variable> is selected then empty the textbox with the path
            if (combobox.SelectedIndex == 0)
            {
                this.txtFilePathFinalSource.Text = "";
                return;
            }

            // If <New variable> is selected then popup to create a new variable
            if (combobox.SelectedIndex == 1)
            {
                int currentdIndex = -1;
                IDtsVariableService _dtsVariableService = _serviceProvider.GetService(typeof(IDtsVariableService)) as IDtsVariableService;
                Variable newVariable = _dtsVariableService.PromptAndCreateVariable(this, null, "FilePath", "User", typeof(String));
                if (newVariable != null)
                {
                    currentdIndex = combobox.Items.Add(newVariable);
                    combobox.SelectedIndex = currentdIndex;
                    return;
                }
                else
                {
                    // Cancel was clicked in popup
                    combobox.SelectedIndex = 0;
                    return;
                }
            }

            // Fill the private variable to store the selected variable
            selectedVariableSource = (Variable)combobox.SelectedItem;

            // If the variable is still null then clear form
            if (selectedVariableSource == null)
            {
                this.cmbVariablesSource.SelectedIndex = 0;
                this.txtFilePathFinalSource.Text = "";
                return;
            }

            // Show path in textbox
            this.txtFilePathFinalSource.Text = (String)selectedVariableSource.Value;
        }
        #endregion

        #region Radio buttons
        private void radConnectionSource_CheckedChanged(object sender, EventArgs e)
        {
            // Enable/disable other fields when
            // the radio button changes
            RadioButton rad = (RadioButton)sender;

            if (!rad.Checked)
            {
                this.cmbConnectionsSource.Enabled = false;
                this.cmbVariablesSource.Enabled = true;
                if (this.cmbVariablesSource.SelectedIndex != 0)
                {
                    Variable var = ((Variable)this.cmbVariablesSource.SelectedItem);
                    if (var != null)
                    {
                        this.txtFilePathFinalSource.Text = ((Variable)this.cmbVariablesSource.SelectedItem).Value.ToString();
                    }
                }
            }
        }

        private void radVariableSource_CheckedChanged(object sender, EventArgs e)
        {
            // Enable/disable other fields when
            // the radio button changes
            RadioButton rad = (RadioButton)sender;
            if (!rad.Checked)
            {
                this.cmbConnectionsSource.Enabled = true;
                this.cmbVariablesSource.Enabled = false;
                if (this.cmbConnectionsSource.SelectedIndex != 0)
                {
                    ConnectionManager temp = ((ConnectionManager)this.cmbConnectionsSource.SelectedItem);
                    if (temp != null)
                    {
                        if (temp.CreationName == "EXCEL")
                        {
                            this.txtFilePathFinalSource.Text = temp.Properties["ExcelFilePath"].GetValue(temp).ToString();
                        }
                        else
                        {
                            this.txtFilePathFinalSource.Text = temp.ConnectionString;
                        }
                    }
                }
            }
        }
        #endregion

        #region Methods to find Connectionmanager and Variable by id
        private ConnectionManager FindConnectionManager(string connectionManagerID)
        {
            // This methods loops through all connection managers
            // and returns the one that matches the GUID.
            foreach (ConnectionManager connManager in this._connections)
            {
                if (connManager.ID == connectionManagerID)
                {
                    return connManager;
                }
            }
            return null;
        }

        private Variable FindVariable(string variableID)
        {
            // This methods loops through all variables
            // and returns the one that matches the GUID.
            foreach (Variable var in this._taskHost.Variables)
            {
                if (var.ID == variableID)
                {
                    return var;
                }
            }
            return null;
        }
        #endregion
    }

    #region ShowConnectionManagerTypeDialog
    // A dialog for creating a new Connection Manager.
    // You can choose between File, FLATFILE or EXCEL
    // and then the corresponding dialog will open.

    // This could also be done in a seperate windows
    // form which is easier to format.
    public static class Prompt
    {
        public static string ShowConnectionManagerTypeDialog()
        {
            Form prompt = new Form();
            prompt.Width = 300;
            prompt.Height = 200;
            prompt.Text = "Choose Connection Manager type";
            prompt.MaximizeBox = false;
            prompt.MinimizeBox = false;
            prompt.ControlBox = false;


            RadioButton radConnectionManagerFile = new RadioButton() { Left = 50, Top = 20, Width = 200, Text = "Connection manager for files", Checked = true };
            RadioButton radConnectionManagerFlatFile = new RadioButton() { Left = 50, Top = 50, Width = 200, Text = "Connection manager for flat files" };
            RadioButton radConnectionManagerExcel = new RadioButton() { Left = 50, Top = 80, Width = 200, Text = "Connection manager for Excel files" };

            Button confirmation = new Button() { Text = "Ok", Left = 150, Width = 100, Top = 110 };
            confirmation.Click += (sender, e) => { prompt.Close(); };
            prompt.Controls.Add(confirmation);
            prompt.Controls.Add(radConnectionManagerFile);
            prompt.Controls.Add(radConnectionManagerFlatFile);
            prompt.Controls.Add(radConnectionManagerExcel);
            prompt.Location = new Point(Screen.PrimaryScreen.WorkingArea.Width / 2 - prompt.Width / 2, Screen.PrimaryScreen.WorkingArea.Height / 2 - prompt.Height / 2);
            prompt.ShowDialog();

            string res = "";
            if (radConnectionManagerExcel.Checked)
            {
                res = "EXCEL";
            }
            else if (radConnectionManagerFlatFile.Checked)
            {
                res = "FLATFILE";
            }
            else
            {
                res = "FILE";
            }

            return res;
        }
    }
    #endregion
}

Copy the number generated. You need it in the next project.

// C# code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.SqlServer.Dts.Runtime;
using System.ComponentModel;
using System.Xml;
using System.IO;

namespace SSISJoost
{
    // Connection to the editor assembly. Copy the PublicKeyToken from the previous step.
    [DtsTask(
    DisplayName = "My Task",
    TaskType = "myTask",
    TaskContact = "SSISJOOST Example",
    IconResource = "SSISJoost.myTask.ico",
    UITypeName = "SSISJoost.myTaskInterface, SSISJoost.myTaskUI, Version=1.0.0.0, Culture=Neutral,PublicKeyToken=80664248b6de6485",
    RequiredProductLevel = DTSProductLevel.None)]
    public class myTask : Task, IDTSComponentPersist
    {

        #region Get Set Properties
        /*
         * The properties of my task that will be
         * saved in the XML of the SSIS package.
         * You can add a Category and Description
         * for each property making it clearer.
         */
        private bool _hasConnectionmanagerSource = true;
        [CategoryAttribute("my Task Source")]
        [Description("True if a connectionmanager is used for the task as source. False if a variable is used.")]
        public bool HasConnectionmanagerSource
        {
            get { return this._hasConnectionmanagerSource; }
            set
            {
                this._hasConnectionmanagerSource = value;
            }
        }

        private string _selectedConnectionManagerIDSource = "";
        [CategoryAttribute("my Task Source")]
        [Description("GUID of the selected source connectionmanager. If a variable is used, then 'SelectedVariableIDSource' is <null>")]
        public string SelectedConnectionManagerIDSource
        {
            get { return this._selectedConnectionManagerIDSource; }
            set { this._selectedConnectionManagerIDSource = value; }
        }

        private string _selectedVariableIDSource = "";
        [CategoryAttribute("my Task Source")]
        [Description("GUID of the selected source variable. If a variable is used, then 'SelectedConnectionManagerIDSource' is <null>")]
        public string SelectedVariableIDSource
        {
            get { return this._selectedVariableIDSource; }
            set { this._selectedVariableIDSource = value; }
        }
        #endregion

        #region Version
        public string Version
        {
            get
            {
                return System.Diagnostics.FileVersionInfo.GetVersionInfo(System.Reflection.Assembly.GetExecutingAssembly().Location).ToString();
            }
        }
        #endregion

        #region Variables for internal use
        private ConnectionManager _selectedConnectionManagerSource = null;
        private Variable _selectedVariableSource = null;
        private string _filePathSource = "";
        #endregion

        #region Constructor
        public myTask()
        {

        }
        #endregion

        #region Overrides for Task
        public override void InitializeTask(Connections connections, VariableDispenser variableDispenser, IDTSInfoEvents events, IDTSLogging log, EventInfos eventInfos, LogEntryInfos logEntryInfos, ObjectReferenceTracker refTracker)
        {
            base.InitializeTask(connections, variableDispenser, events, log, eventInfos, logEntryInfos, refTracker);
        }

        public override DTSExecResult Validate(Connections connections, VariableDispenser variableDispenser, IDTSComponentEvents componentEvents, IDTSLogging log)
        {

            // If we have used a ConnectionManager then we check if we have a valid one !
            if (HasConnectionmanagerSource)
            {
                try
                {
                    // Check if a connection manager is selected in the combobox
                    if (String.IsNullOrEmpty(this._selectedConnectionManagerIDSource))
                    {
                        throw new ApplicationException("Connectionmanager is mandatory for source");
                    }

                    // Check if the selected connection manager still exists
                    if (FindConnectionManager(connections, _selectedConnectionManagerIDSource) == null)
                    {
                        throw new ApplicationException("Invalid connectionmanager for source");
                    }
                }
                catch (System.Exception e)
                {
                    componentEvents.FireError(0, "My Task", "Invalid Source Connectionmanager.", "", 0);
                    return DTSExecResult.Failure;
                }
            }
            else
            // If we decided to use a Variable we at least must have chosen one !
            {
                if (String.IsNullOrEmpty(this._selectedVariableIDSource))
                {
                    componentEvents.FireError(0, "My Task", "Selected Source Variable is mandatory", "", 0);
                    return DTSExecResult.Failure;
                }
            }


            /*
             * If you want to do some checks with the value from the connection manager or variable then
             * you have to get that value. You can copy the code from the execute and then use that to
             * validate the filepath from the connection manager or variable.
             */

            return DTSExecResult.Success;
        }

        public override DTSExecResult Execute(Connections connections, VariableDispenser variableDispenser, IDTSComponentEvents componentEvents, IDTSLogging log, object transaction)
        {

            // Do the base Validation, if result is OK, then we continue
            if (base.Execute(connections, variableDispenser, componentEvents, log, transaction) == DTSExecResult.Failure)
            {
                return DTSExecResult.Failure;
            }

            // Get the value from the connection manager or variable
            if (HasConnectionmanagerSource)
            {
                _selectedConnectionManagerSource = FindConnectionManager(connections, _selectedConnectionManagerIDSource);
                _filePathSource = GetFilePathSource(_selectedConnectionManagerSource);
            }
            else
            {
                _selectedVariableSource = FindVariable(variableDispenser, _selectedVariableIDSource);
                _filePathSource = GetFilePathSource(_selectedVariableSource);
            }

            if (!File.Exists(_filePathSource))
            {
                componentEvents.FireError(0, "My Task", "File " + _filePathSource + " doesn't exist", "", 0);
                return DTSExecResult.Failure;
            }
            else
            {
                return DTSExecResult.Success;
            }
        }
        #endregion

        #region Methods for IDTSComponentPersist
        void IDTSComponentPersist.LoadFromXML(System.Xml.XmlElement node, IDTSInfoEvents infoEvents)
        {
            // This might occur if the task's XML has been modified outside of the Business Intelligence
            // Or SQL Server Workbenches.
            if (node.Name != "UnzipTask")
            {
                throw new Exception(string.Format("Unexpected task element when loading task - {0}.", "UnzipTask"));
            }
            else
            {
                // populate the private property variables with values from the DTS node.
                this._hasConnectionmanagerSource = Convert.ToBoolean(node.Attributes.GetNamedItem("HasConnectionmanagerSource").Value);
                this._selectedConnectionManagerIDSource = node.Attributes.GetNamedItem("SelectedConnectionManagerIDSource").Value;
                this._selectedVariableIDSource = node.Attributes.GetNamedItem("SelectedVariableIDSource").Value;
            }
        }

        void IDTSComponentPersist.SaveToXML(System.Xml.XmlDocument doc, IDTSInfoEvents infoEvents)
        {
            //create node in the package xml document
            XmlElement taskElement = doc.CreateElement(string.Empty, "UnzipTask", string.Empty);

            // create attributes in the node that represent the custom properties and add each to the element

            // Boolean indicating if you are using a connection manager or variable
            XmlAttribute UnzipTaskXmlAttribute = doc.CreateAttribute(string.Empty, "HasConnectionmanagerSource", string.Empty);
            UnzipTaskXmlAttribute.Value = this._hasConnectionmanagerSource.ToString();
            taskElement.Attributes.Append(UnzipTaskXmlAttribute);

            // The GUID from the connection manager
            UnzipTaskXmlAttribute = doc.CreateAttribute(string.Empty, "SelectedConnectionManagerIDSource", string.Empty);
            UnzipTaskXmlAttribute.Value = this._selectedConnectionManagerIDSource.ToString();
            taskElement.Attributes.Append(UnzipTaskXmlAttribute);

            // The GUID from the variable
            UnzipTaskXmlAttribute = doc.CreateAttribute(string.Empty, "SelectedVariableIDSource", string.Empty);
            UnzipTaskXmlAttribute.Value = this._selectedVariableIDSource.ToString();
            taskElement.Attributes.Append(UnzipTaskXmlAttribute);

            //add the new element to the package document
            doc.AppendChild(taskElement);
        }
        #endregion

        #region CUSTOM Methods for getting path via Variable or Connectionmanager
        private string GetFilePathSource(ConnectionManager selectedConnectionManager)
        {
            if (selectedConnectionManager != null)
            {
                if (selectedConnectionManager.CreationName == "EXCEL")
                {
                    return selectedConnectionManager.Properties["ExcelFilePath"].GetValue(_selectedConnectionManagerSource).ToString();
                }
                else
                {
                    return selectedConnectionManager.ConnectionString;
                }
            }
            else
            {
                return "";
            }
        }

        private string GetFilePathSource(Variable selectedVariable)
        {
            if (selectedVariable != null)
            {
                return (String)_selectedVariableSource.Value;
            }
            else
            {
                return "";
            }
        }

        private Variable FindVariable(VariableDispenser variableDispenser, string variableID)
        {
            Variable tempVariable = null;
            if (variableDispenser.Contains(_selectedVariableIDSource))
            {
                Variables vars = null;
                variableDispenser.LockOneForRead(variableID, ref vars);

                if (vars != null)
                {
                    foreach (Variable var in vars)
                    {
                        if (var.ID == variableID)
                        {
                            tempVariable = var;
                        }
                    }
                }
                vars.Unlock();
            }
            return tempVariable;
        }

        private ConnectionManager FindConnectionManager(Connections connections, string connectionManagerID)
        {
            ConnectionManager tempConnManager = null;
            foreach (ConnectionManager connManager in connections)
            {
                if (connManager.ID == connectionManagerID)
                {
                    tempConnManager = connManager;
                }
            }
            return tempConnManager;
        }
        #endregion
    }
}

Your own custom SSIS task

Simplified version of my staging package (times 150)

Add New Biml File

Truncate table Color














SELECT Code, Name FROM Color

Right Click and choose Generate SSIS packages

Screenshot, because the mixed BIML and C# code isn't readable in HTML

Master package example 1: loop through SSISDB

Master package 2: loop through project folder on filesystem

ISNULL([Column1]) && ISNULL([Column2])

An error occurred while parsing EntityName

ISNULL([Column1]) && ISNULL([Column2])





ISNULL([Column1]) <![CDATA[&&]]> ISNULL([Column2])

1. Send Mail Task
2. Script Task with SmtpClient Class
3. Execute SQL Task with sp_send_dbmail
4. Custom Tasks like Send HTML Mail Task or COZYROC

Add these four variables to your package

Database Mail

Enable Database Mail and create profile

Create a mail profile

Configure SMTP and FROM address

Account ready, continue wizard

Public profile

Configure System Parameters

Finish

Close

OLE DB Connection Manager

' Stored Procedure with parameters
EXEC msdb.dbo.sp_send_dbmail
    @profile_name = 'SSIS Joost Mail Profile',
    @recipients = ?,
    @subject = ?,
    @body = ?,
    @body_format = 'HTML' ;

sp_send_dbmail in SSIS

Parameters

An email with html formatting

1. Send Mail Task
2. Script Task with SmtpClient Class
3. Execute SQL Task with sp_send_dbmail
4. Custom Tasks like Send HTML Mail Task or COZYROC

Add these four variables to your package

SMTP Connection manager

Add all SSIS variables as ReadOnly

// C# Code
using System;
using System.Data;
using Microsoft.SqlServer.Dts.Runtime;
using System.Windows.Forms;
using System.Net.Mail;          // Added

namespace ST_df6618207373422d961b80ca8b6a56e2
{
    [Microsoft.SqlServer.Dts.Tasks.ScriptTask.SSISScriptTaskEntryPointAttribute]
    public partial class ScriptMain : Microsoft.SqlServer.Dts.Tasks.ScriptTask.VSTARTScriptObjectModelBase
    {
        public void Main()
        {
            // Storing SSIS variables in .Net variables. You could skip this step and call the SSIS variables in the actual mail code
            // to reduce the number of code lines. Or you could fill these .Net variables with hardcoded values.
            String SendMailFrom = Dts.Variables["SendMailFrom"].Value.ToString();
            String SendMailTo = Dts.Variables["SendMailTo"].Value.ToString();
            String SendMailSubject = Dts.Variables["SendMailSubject"].Value.ToString();
            String SendMailBody = Dts.Variables["SendMailBody"].Value.ToString();

            // Get SMTP Server from SMTP Connection Manager. Alternative is to use extra variables or paramters instead:
            // String SmtpServer = Dts.Variables["SmtpServer"].Value.ToString();
            String SmtpServer = Dts.Connections["My SMTP Connection Manager"].Properties["SmtpServer"].GetValue(Dts.Connections["My SMTP Connection Manager"]).ToString();

            // Create an email and change the format to HTML
            MailMessage myHtmlFormattedMail = new MailMessage(SendMailFrom, SendMailTo, SendMailSubject, SendMailBody);
            myHtmlFormattedMail.IsBodyHtml = true;

            // Create a SMTP client to send the email
            SmtpClient mySmtpClient = new SmtpClient(SmtpServer);
            mySmtpClient.Port = 2525; // If you want to use a different portnumber instead of the default. Else remove this line.
            mySmtpClient.Send(myHtmlFormattedMail);

            // Close Script Task with success
            Dts.TaskResult = (int)ScriptResults.Success;
        }

        #region ScriptResults declaration

        enum ScriptResults
        {
            Success = Microsoft.SqlServer.Dts.Runtime.DTSExecResult.Success,
            Failure = Microsoft.SqlServer.Dts.Runtime.DTSExecResult.Failure
        };
        #endregion
    }
}

' VB.Net Code
Imports System
Imports System.Data
Imports System.Math
Imports Microsoft.SqlServer.Dts.Runtime
Imports System.Net.Mail             ' Added

<Microsoft.SqlServer.Dts.Tasks.ScriptTask.SSISScriptTaskEntryPointAttribute()> _
<System.CLSCompliantAttribute(False)> _
Partial Public Class ScriptMain
    Inherits Microsoft.SqlServer.Dts.Tasks.ScriptTask.VSTARTScriptObjectModelBase

    Public Sub Main()
        ' Storing SSIS variables in .Net variables. You could skip this step and call the SSIS variables in the actual mail code
        ' to reduce the number of code lines. Or you could fill these .Net variables with hardcoded values.
        Dim SendMailFrom As String = Dts.Variables("SendMailFrom").Value.ToString()
        Dim SendMailTo As String = Dts.Variables("SendMailTo").Value.ToString()
        Dim SendMailSubject As String = Dts.Variables("SendMailSubject").Value.ToString()
        Dim SendMailBody As String = Dts.Variables("SendMailBody").Value.ToString()

        ' Get SMTP Server from SMTP Connection Manager. Alternative is to use extra variables or paramters instead:
        ' Dim SmtpServer as String = Dts.Variables("SmtpServer").Value.ToString();
        Dim SmtpServer As String = Dts.Connections("My SMTP Connection Manager").Properties("SmtpServer").GetValue(Dts.Connections("My SMTP Connection Manager")).ToString()

        ' Create an email and change the format to HTML
        Dim myHtmlFormattedMail As New MailMessage(SendMailFrom, SendMailTo, SendMailSubject, SendMailBody)
        myHtmlFormattedMail.IsBodyHtml = True

        ' Create a SMTP client to send the email
        Dim mySmtpClient As New SmtpClient(SmtpServer)
        mySmtpClient.Port = 2525 ' If you want to use a different portnumber instead of the default. Else remove this line.
        mySmtpClient.Send(myHtmlFormattedMail)

        ' Close Script Task with success

        Dts.TaskResult = ScriptResults.Success
    End Sub

#Region "ScriptResults declaration"
    'This enum provides a convenient shorthand within the scope of this class for setting the
    'result of the script.

    'This code was generated automatically.
    Enum ScriptResults
        Success = Microsoft.SqlServer.Dts.Runtime.DTSExecResult.Success
        Failure = Microsoft.SqlServer.Dts.Runtime.DTSExecResult.Failure
    End Enum

#End Region

End Class

HTML formatted email

1. Send Mail Task
2. Script Task with SmtpClient Class
3. Execute SQL Task with sp_send_dbmail
4. Custom Tasks like Send HTML Mail Task or COZYROC

Add these four variables to your package

SMTP Connection manager

Select SMTP Connection Manager

Expressions

No HTML Formatting

My first SSIS Connection Manager

Two projects for my Connection Manager

Microsoft (R) .NET Framework Strong Name Utility

Add key to projects

Sign Assembly

• Microsoft.SqlServer.Dts.Design
• Microsoft.SQLServer.ManagedDTS

• Microsoft.SQLServer.ManagedDTS

Add references

Post-build events

Icon for editor

// C# code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Microsoft.SqlServer.Dts.Design;
using Microsoft.SqlServer.Dts.Runtime;
using Microsoft.SqlServer.Dts.Runtime.Design;

// Interface for connection editor
namespace SSISJoost
{
    public class myConnectionManagerInterface : IDtsConnectionManagerUI
    {
        private ConnectionManager _connectionManager;
        private IServiceProvider _serviceProvider;

        public myConnectionManagerInterface()
        {

        }

        public void Initialize(ConnectionManager connectionManager, IServiceProvider serviceProvider)
        {
            this._connectionManager = connectionManager;
            this._serviceProvider = serviceProvider;
        }


        public ContainerControl GetView()
        {
            myConnectionManagerEditor editor = new myConnectionManagerEditor();
            editor.ConnectionManager = this._connectionManager;
            editor.ServiceProvider = this._serviceProvider;
            return editor;
        }

        public void Delete(IWin32Window parentWindow)
        {
        }

        public void New(IWin32Window parentWindow)
        {
        }

        public bool Edit(System.Windows.Forms.IWin32Window parentWindow, Microsoft.SqlServer.Dts.Runtime.Connections connections, Microsoft.SqlServer.Dts.Runtime.Design.ConnectionManagerUIArgs connectionUIArg)
        {
            myConnectionManagerEditor editor = new myConnectionManagerEditor();

            editor.Initialize(_connectionManager, this._serviceProvider);
            if (editor.ShowDialog(parentWindow) == DialogResult.OK)
            {
                editor.Dispose();
                return true;
            }
            else
            {
                editor.Dispose();
                return false;
            }
        }

        public bool New(System.Windows.Forms.IWin32Window parentWindow, Microsoft.SqlServer.Dts.Runtime.Connections connections, Microsoft.SqlServer.Dts.Runtime.Design.ConnectionManagerUIArgs connectionUIArg)
        {
            myConnectionManagerEditor editor = new myConnectionManagerEditor();

            editor.Initialize(_connectionManager, this._serviceProvider);
            if (editor.ShowDialog(parentWindow) == DialogResult.OK)
            {
                editor.Dispose();
                return true;
            }
            else
            {
                editor.Dispose();
                return false;
            }
        }
    }
}

// C# code
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using Microsoft.SqlServer.Dts.Design;
using Microsoft.SqlServer.Dts.Runtime;
using Microsoft.SqlServer.Dts.Runtime.Design;


namespace SSISJoost
{
    public partial class myConnectionManagerEditor : Form
    {
        #region General Connection Manager Methods
        // Setting and getting ConnectionManager
        private ConnectionManager _connectionManager;
        public ConnectionManager ConnectionManager
        {
            get { return _connectionManager; }
            set { _connectionManager = value; }
        }

        // Setting and getting ServiceProvider
        private IServiceProvider _serviceProvider = null;
        public IServiceProvider ServiceProvider
        {
            get { return _serviceProvider; }
            set { _serviceProvider = value; }
        }

        // Default constructor
        public myConnectionManagerEditor()
        {
            InitializeComponent();
        }

        public void Initialize(ConnectionManager connectionManager, IServiceProvider serviceProvider)
        {
            this._connectionManager = connectionManager;
            this._serviceProvider = serviceProvider;
        }
        #endregion

        #region Page Load
        // Fill the fields of the form. Get data from connectionManager object
        private void SMTP2Editor_Load(object sender, EventArgs e)
        {
            this.txtName.Text = this._connectionManager.Name;
            this.txtDescription.Text = this._connectionManager.Description;
            this.txtURL.Text = this._connectionManager.Properties["URL"].GetValue(_connectionManager).ToString();
            this.txtUserName.Text = this._connectionManager.Properties["UserName"].GetValue(_connectionManager).ToString();
            this.txtPassword.Text = this._connectionManager.Properties["Password"].GetValue(_connectionManager).ToString();
        }
        #endregion

        #region Buttons
        // Save value from fields in connectionManager object
        private void btnOK_Click(object sender, EventArgs e)
        {
            this._connectionManager.Name = this.txtName.Text;
            this._connectionManager.Description = this.txtDescription.Text;
            this._connectionManager.Properties["URL"].SetValue(this._connectionManager, this.txtURL.Text);
            this._connectionManager.Properties["UserName"].SetValue(this._connectionManager, this.txtUserName.Text);
            this._connectionManager.Properties["Password"].SetValue(this._connectionManager, this.txtPassword.Text);
            this.DialogResult = DialogResult.OK;
        }

        // Cancel diolog
        private void btnCancel_Click(object sender, EventArgs e)
        {
            this.DialogResult = DialogResult.Cancel;
        }

        // Show some helpful information
        private void btnHelp_Click(object sender, EventArgs e)
        {
            MessageBox.Show("Help");
        }
        #endregion
    }
}

Copy the number generated. You need it in the next project.

// C# code
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Xml;
using Microsoft.SqlServer.Dts.Runtime;

namespace SSISJoost
{
    // Connection to the editor assembly. Copy the PublicKeyToken from the previous step.
    [DtsConnection(
        ConnectionType = "myConnectionManager",
        DisplayName = "My Connection Manger",
        ConnectionContact = "SSISJoost",
        Description = "My Custom Connection manager",
        //IconResource = "SSISJoost.myConnectionManager.myConnectionManager.ico", // Bug in SSIS => No custom icons for Connection Managers
        UITypeName = "SSISJoost.myConnectionManagerInterface,SSISJoost.myConnectionManagerUI,Version=1.0.0.0,Culture=neutral,PublicKeyToken=80664248b6de6485")
    ]
    public class myConnectionManager : ConnectionManagerBase, IDTSComponentPersist
    {
        #region Variables for internal use
        // The template for the connectionstring, but without the sensitive password property
        private const string CONNECTIONSTRING_TEMPLATE = "URL=<URL>;UserName=<UserName>;";
        #endregion

        #region Get Set Properties
        /*
         * The properties of my connection manager that
         * will be saved in the XML of the SSIS package.
         * You can add a Category and Description
         * for each property making it clearer.
         */
        private string _connectionString = String.Empty;
        public override string ConnectionString
        {
            get
            {
                UpdateConnectionString();
                return _connectionString;
            }
            //connectionstring is now readonly
            //set
            //{
            //    _connectionString = value;
            //}
        }

        private string _url = String.Empty;
        [CategoryAttribute("my connection manager")]
        [Description("Some URL to do something with in an other task or transformation")]
        public string URL
        {
            get { return this._url; }
            set { this._url = value; }
        }

        private string _userName = String.Empty;
        [CategoryAttribute("my connection manager")]
        [Description("The username needed to access the url")]
        public string UserName
        {
            get { return this._userName; }
            set { this._userName = value; }
        }

        // Notice the password property to hide the chars
        private string _password = String.Empty;
        [CategoryAttribute("my connection manager")]
        [Description("The secret password")]
        [PasswordPropertyText(true)]
        public string Password
        {
            get { return this._password; }
            set { this._password = value; }
        }
        #endregion

        #region Overriden methods
        public override object AcquireConnection(object txn)
        {
            // Set the connectionstring
            UpdateConnectionString();
            return base.AcquireConnection(txn);
        }

        public override void ReleaseConnection(object connection)
        {
            base.ReleaseConnection(connection);
        }

        public override DTSExecResult Validate(IDTSInfoEvents infoEvents)
        {
            // Very basic validation example:
            // Check if the URL field is filled.
            // Note: this is a runtime validation
            // In the form you can add some more
            // designtime validation.
            if (string.IsNullOrEmpty(_url))
            {
                infoEvents.FireError(0, "My Custom Connection Manager", "URL is mandatory.", string.Empty, 0);
                return DTSExecResult.Failure;
            }
            else
            {
                return DTSExecResult.Success;
            }
        }
        #endregion

        #region Update ConnectionString
        private void UpdateConnectionString()
        {
            // Create a connectionstring, but without sensitive properties like the password
            String connectionString = CONNECTIONSTRING_TEMPLATE;

            connectionString = connectionString.Replace("<URL>", URL);
            connectionString = connectionString.Replace("<UserName>", UserName);

            _connectionString = connectionString;
        }
        #endregion

        #region Methods for IDTSComponentPersist
        // These two methods are for saving the data in the package XML without showing sensitive data
        void IDTSComponentPersist.LoadFromXML(System.Xml.XmlElement node, IDTSInfoEvents infoEvents)
        {
            // Checking if XML is correct. This might occur if the connection manager XML has been modified outside BIDS/SSDT
            if (node.Name != "MYCONNECTIONMANAGER")
            {
                throw new Exception(string.Format("Unexpected connectionmanager element when loading task - {0}.", "MYCONNECTIONMANAGER"));
            }
            else
            {
                // Fill properties with values from package XML
                this._userName = node.Attributes.GetNamedItem("UserName").Value;
                this._url = node.Attributes.GetNamedItem("URL").Value;


                foreach (XmlNode childNode in node.ChildNodes)
                {
                    if (childNode.Name == "Password")
                    {
                        this._password = childNode.InnerText;
                    }
                }
                this._connectionString = node.Attributes.GetNamedItem("ConnectionString").Value;
            }
        }

        void IDTSComponentPersist.SaveToXML(System.Xml.XmlDocument doc, IDTSInfoEvents infoEvents)
        {
            XmlElement rootElement = doc.CreateElement("MYCONNECTIONMANAGER");
            doc.AppendChild(rootElement);

            XmlAttribute connectionStringAttr = doc.CreateAttribute("ConnectionString");
            connectionStringAttr.Value = _connectionString;
            rootElement.Attributes.Append(connectionStringAttr);

            XmlAttribute userNameStringAttr = doc.CreateAttribute("UserName");
            userNameStringAttr.Value = _userName;
            rootElement.Attributes.Append(userNameStringAttr);

            XmlAttribute urlStringAttr = doc.CreateAttribute("URL");
            urlStringAttr.Value = _url;
            rootElement.Attributes.Append(urlStringAttr);

            if (!string.IsNullOrEmpty(_password))
            {
                XmlElement passwordElement = doc.CreateElement("Password");
                rootElement.AppendChild(passwordElement);
                passwordElement.InnerText = _password;

                // This will make the password property sensitive
                XmlAttribute passwordAttr = doc.CreateAttribute("Sensitive");
                passwordAttr.Value = "1";
                passwordElement.Attributes.Append(passwordAttr);
            }
        }
        #endregion
    }
}

Executing packages sequentially

4 cores => execute 4 child packages at the same time

-- Create QUEUE table
CREATE TABLE [dbo].[FifoPackageQueue](
 [Id] [bigint] IDENTITY(1,1) NOT NULL,
 [Package] [varchar](50) NULL
) ON [PRIMARY]

GO

-- Add Index on Id
CREATE CLUSTERED INDEX cdxFifoPackageQueue on FifoPackageQueue (Id)

GO

-- Log tabel
CREATE TABLE [dbo].[FifoPackageQueueLog](
 [Id] [bigint] IDENTITY(1,1) NOT NULL,
 [Package] [varchar](50) NULL,
 [StartTime] [datetime] NULL,
 [EndTime] [datetime] NULL
) ON [PRIMARY]

GO

String variables, one per execution line

Integer Package Parameter.

INSERT INTO CONV_LOG..FifoPackageQueue
(
     [Package]
)
SELECT      Packages.[name]
FROM        [SSISDB].[internal].[packages] as Packages
INNER JOIN  [SSISDB].[internal].[projects] as Projects
            on Packages.project_version_lsn = Projects.object_version_lsn
WHERE       Projects.name = 'MyProject'
AND         Packages.name like 'STG%';

Expression to limit the number of parallel executions

Output clause is available in SQL 2005

set nocount on;

-- Declare temporary table to store the result of the delete
DECLARE @TmpTable TABLE (Package varchar(50));
-- Declare integer variable for counting the delete result
DECLARE @PackageCount int;

-- Select first record, lock it, delete it and store name in temporary table
WITH cte as (
   SELECT  top(1) Package
   FROM  FifoPackageQueue WITH (rowlock, readpast)
   ORDER BY Id
   )
DELETE FROM cte
output deleted.Package INTO @TmpTable

-- Check if there is 1 record in temporary table
SELECT @PackageCount = count(*) FROM @TmpTable
if @PackageCount = 1
BEGIN
 -- Return package name
 SELECT Package FROM @TmpTable
END
ELSE
BEGIN
 -- Temporary table was empty so queue was empty
 -- Return empty string to stop next precedence constraint
 SELECT '' as Package
END

Store package name in SSIS variable

Loop until empty

INSERT INTO  FifoPackageQueueLog (Package, StartTime)
VALUES   (?, GETDATE())

UPDATE  FifoPackageQueueLog
SET   EndTime = GETDATE()
WHERE  Package = ?
AND   EndTime is null

SELECT AddressLine1, AddressLine2, City FROM Address







0
Salt123

|