/// <summary> /// Initializes a multi-dimensional array. /// </summary> /// <typeparam name="A">The type of the array including the dimensions in the form 'string[,,]'.</typeparam> /// <param name="lengths">The length of each dimension.</param> /// <param name="lowerBounds">The lower bounds to use for each dimension.</param> /// <param name="constructorParams">The list of values to be sent to /// the constructor of the item type of the array.</param> /// <returns>A new multi-dimensional array with its values initialized to a default value.</returns> public static A InitializeArray <A>(int[] lengths, int[] lowerBounds, object[] constructorParams) where A : class { if ((lengths == null) || (lowerBounds == null) || (constructorParams == null)) { throw new NullReferenceException("AIS-Exception. Either 'lengths', 'lowerBounds' or 'constructorParams' parameter is null"); } Type arrayType = typeof(A); if (!arrayType.IsArray) { throw new Exception("AIS-Exception. Array type is expected as parameter"); } Type itemType = arrayType.GetElementType(); if (itemType == null) { throw new NullReferenceException("AIS-Exception. itemType for the array couldn't be resolved"); } InitialValueProvider valueProvider = new InitialValueProvider(itemType, constructorParams); //Only Primitive types and strings can be initialized with the same value, for other types a new instance //will be used for each element if (itemType.IsPrimitive || itemType.Equals(typeof(string))) { return(InternalInitializeArray(lengths, lowerBounds, itemType, valueProvider.GetInitialValue()) as A); } return(InternalInitializeArray(lengths, lowerBounds, itemType, valueProvider) as A); }
/// <summary> /// Fills the one-dimension targetArray with either matching cell values from /// sourceArray or with a initial value. /// </summary> /// <param name="sourceArray">The array object containing the values to copy.</param> /// <param name="targetArray">The new array where to copy the values.</param> /// <param name="valueProvider">a <c>InitialValueProvider</c> object used to get /// the default values for the new cells.</param> private static void FillsOneDimensionArray(Array sourceArray, Array targetArray, InitialValueProvider valueProvider) { Array.Copy(sourceArray, sourceArray.GetLowerBound(0), targetArray, sourceArray.GetLowerBound(0), Math.Min(targetArray.GetLength(0), sourceArray.GetLength(0))); if (targetArray.Length > sourceArray.Length) { for (int i = sourceArray.Length; i < targetArray.Length; i++) { targetArray.SetValue(valueProvider.GetInitialValue(), i + targetArray.GetLowerBound(0)); } } }
/// <summary> /// Fills the one-dimension targetArray with either matching cell values from /// sourceArray or with a initial value. /// </summary> /// <param name="sourceArray">The array object containing the values to copy.</param> /// <param name="targetArray">The new array where to copy the values.</param> /// <param name="valueProvider">a <c>InitialValueProvider</c> object used to get /// the default values for the new cells.</param> /// <param name="bFixedLengthString">Optional bolean flag that indicates if the current array type is fixed length string (original vb6 code) - /// its default value is false, because it will be generated in upgraded code when current array type used to be a fixed length string.</param> /// <param name="iFixedLengthStringSize">Optional integer value that indicates what is the fixed length string size, used in conjunction with previous (bFixedLengthString) parameter.</param> private static void FillsOneDimensionArray(Array sourceArray, Array targetArray, InitialValueProvider valueProvider, bool bFixedLengthString = false, int iFixedLengthStringSize = 0) { if (targetArray.Length > sourceArray.Length) { for (int i = sourceArray.Length; i < targetArray.Length; i++) { targetArray.SetValue(valueProvider.GetInitialValue(bFixedLengthString, iFixedLengthStringSize), i + targetArray.GetLowerBound(0)); } } Array.Copy(sourceArray, sourceArray.GetLowerBound(0), targetArray, sourceArray.GetLowerBound(0), Math.Min(targetArray.GetLength(0), sourceArray.GetLength(0))); }
/// <summary> /// Fills the n-dimension targetArray with either matching cell values from /// sourceArray or with a initial value. /// </summary> /// <param name="sourceArray">The array object containing the values to copy.</param> /// <param name="targetArray">The new array where to copy the values.</param> /// <param name="valueProvider">a <c>InitialValueProvider</c> object used to get /// the default values for the new cells.</param> private static void FillsMultiDimensionalArray(Array sourceArray, Array targetArray, InitialValueProvider valueProvider) { int rowsToCopy = GetFirstDimensionsSize(sourceArray); int originalLastDimensionSize = GetLastDimensionSize(sourceArray); int newLastDimensionSize = GetLastDimensionSize(targetArray); int newCells = newLastDimensionSize - originalLastDimensionSize; int lowerBound = sourceArray.GetLowerBound(0); // creates a new array with same dimensions than the target array (but a smaller one version) to hold the // default values to copy Array arrayLen = Array.CreateInstance(typeof(Int32), targetArray.Rank); for (int i = 0; i < targetArray.Rank - 1; i++) { arrayLen.SetValue(1, i); } arrayLen.SetValue(targetArray.GetLength(targetArray.Rank - 1), targetArray.Rank - 1); Array defaultValues = Array.CreateInstance(targetArray.GetType().GetElementType(), (int[])arrayLen); for (int i = 0; i < rowsToCopy; i++) { //copies the values from source array to target aray Array.Copy(sourceArray, (i * originalLastDimensionSize) + lowerBound, targetArray, (i * newLastDimensionSize) + lowerBound, Math.Min(originalLastDimensionSize, newLastDimensionSize)); // fills the remaining cells with the default value if (newCells > 0) { for (int k = 0; k < arrayLen.Length; k++) { arrayLen.SetValue(0, k); // initilizing the indixes to first array element (0 on all dimensions) } // sets up the default values array with new values (we delegate to the value provider the responsability to get either // a new or an old instance. for (int j = originalLastDimensionSize; j < newLastDimensionSize; j++) { arrayLen.SetValue(j - originalLastDimensionSize, arrayLen.Length - 1); // moves the index defaultValues.SetValue(valueProvider.GetInitialValue(), (int[])arrayLen); } Array.Copy(defaultValues, 0, targetArray, (i * newLastDimensionSize) + originalLastDimensionSize + lowerBound, newCells); } } }