How to write array in Excel User Defined Function

I have an Excel Addin created using Excel-DNA and have a UDF as part of the Excel Add-In. Lets say that the function is in Cell A10 and I go to delete Column Z. I have found that this action causes the function to execute again.

Is there a way to prevent this behavior from occurring? Does this have to do with the calculation model or volatility?

EDIT 1

I am using the following code to implement behavior like the Bloomberg BDH functionality - i.e. that the function is written in the first cell and the rest of the array is written via a thread.

I have 2 problems:

1. I cannot determine how to have a message flash in the cell where the function is written. For example, if the function is run in Cell A1, the message "Processing..." is displayed until the value of the cell has been written.
2. The recalculation of functions occurs with this implementation.

I have seen implementations where items 1 & 2 above are working well, but cannot determine how to do so. Does anybody have any ideas

public class ArrayWriter
{
    #region Methods

    #region WriteArray
    [ExcelFunction(IsHidden=true)]
    public object WriteArray(object[,] arrayToWrite)
    {
        object caller = null;
        object formula = null;
        AddInFacade facade;

        // if not in a function
        if (!ExcelDnaUtil.IsInFunctionWizard())
        {
            facade = new AddInFacade();

            if (arrayToWrite != null)
            {
                // if writing more than one cell, use threads
                if (arrayToWrite.GetLength(0) > 1 || arrayToWrite.GetLength(1) > 1)
                {
                    var xlApp = ExcelDnaUtil.Application as Application;
                    Type xlAppType = xlApp.GetType();

                    caller = xlApp.Caller;
                    //caller = xlAppType.InvokeMember("ActiveCell", BindingFlags.GetProperty, null, xlApp, null);
                    formula = xlAppType.InvokeMember("FormulaR1C1Local", BindingFlags.GetProperty, null, caller, null);

                    // create instance of ObjectForThread and set all properties of the class
                    ObjectForThread threadObject = new ObjectForThread()
                    {
                        xlRef = caller,
                        value = arrayToWrite,
                    };

                    // create a new thread calling the method WriteFromThread and start the thread
                    Thread threadWriter = new Thread(() => WriteFromThread(threadObject));
                    threadWriter.Start();
                }
                else
                {
                    facade.SetMouseCursor(XlMousePointer.xlDefault);
                }
            }
            else
            {
                arrayToWrite = new object[1, 1];
                arrayToWrite[0, 0] = "No data was returned.";
                facade.SetMouseCursor(XlMousePointer.xlDefault);
            }
        }

        return arrayToWrite[0,0];
    }
    #endregion

    #region WriteFromThread
    private void WriteFromThread(Object boxedThreadObject)
    {
        AddInFacade facade = new AddInFacade();

        ObjectForThread unboxedThreadObject = (ObjectForThread)boxedThreadObject;
        Object cellBelow;

        Type typeCellReference = unboxedThreadObject.xlRef.GetType();

        try
        {
            for (int i = 0; i < unboxedThreadObject.value.GetLength(0); i++)
            {
                for (int j = 0; j < unboxedThreadObject.value.GetLength(1); j++)
                {
                    // do not write the first cell as this is what is returned by the function
                    if (i > 0 || j > 0)
                    {
                        cellBelow = typeCellReference.InvokeMember("Offset", BindingFlags.GetProperty, null, unboxedThreadObject.xlRef, new object[] { i, j });
                        typeCellReference.InvokeMember("Value", BindingFlags.SetProperty, null, cellBelow, new[] { Type.Missing, unboxedThreadObject.value[i, j] });
                    }
                }
            }
        }
        catch(Exception ex)
        {
            string szError = ex.Message;
        }
        finally
        {
            // attempt to kill all COM references
            unboxedThreadObject.xlRef = null;
            unboxedThreadObject.value = null;

            //Set the mouse cursor to the default cursor since the entire array has now been written
            facade.SetMouseCursor(XlMousePointer.xlDefault);

            unboxedThreadObject = null;
            cellBelow = null;
            facade = null;
        }
    }
    #endregion

    #endregion

    #region ObjectForThread Class
    public class ObjectForThread
    {
        public object xlRef { get; set; }
        public object[,] value { get; set; }
    }
    #endregion
}