Array-Analyse mit einer Untergrenze ungleich Null in C#

Wenn man über Arrays spricht und gefragt wird, bei welcher Zahl das Array beginnt, werden die meisten Programmierer schätzungsweise direkt sagen, dass das Array mit Sicherheit bei 0 beginnt. Diese Antwort ist natürlich richtig. Schauen wir uns nun Arrays mit einer Untergrenze ungleich Null in C# an.

Werfen wir zunächst einen Blick auf die entsprechende Einführung zu Arrays:

1. Array: Dabei handelt es sich um einen Mechanismus, der die Verarbeitung mehrerer Datenelemente als Sammlung ermöglicht.

2. Klassifizierung von Arrays: In CLR können Arrays in eindimensionale Arrays, mehrdimensionale Arrays und verschachtelte Arrays unterteilt werden.

3. Array-Typ: Da alle Arrays vom abstrakten Typ System.Array erben und dieser Typ von System.Object erbt, bedeutet dies, dass das Array ein Referenztyp ist.

Beim Erstellen eines Arrays enthält der vom Array-Objekt belegte Speicherblock zusätzlich zu den Array-Elementen auch einen Typobjektzeiger, einen synchronisierten Indexblock und ein zusätzliches Mitglied. Die oben erwähnte Klassifizierung von Arrays ist „verschachtelte Arrays“. Da die CLR verschachtelte Arrays unterstützt, können verschachtelte Arrays in C# implementiert werden. Der Zugriff auf die Elemente eines verschachtelten Arrays muss zweimal erfolgen . Oder mehrere Array-Zugriffe.

Wenn das Array während der zugehörigen Operationen am Array als tatsächlicher Parameter an eine Methode übergeben wird, wird tatsächlich ein Verweis auf das Array übergeben, sodass die aufgerufene Methode die Elemente im Array ändern kann. (Wenn Sie nicht geändert werden möchten, müssen Sie eine Kopie des Arrays generieren und diese Kopie an die Methode übergeben.)

Hier ist eine Methode zum Konvertieren eines Arrays in eine DataTable:

       /// <summary>
        /// 整数型二维数组转换成DataTable
        /// </summary>
        /// <param name="intDyadicArray"></param>
        /// <param name="messageOut"></param>
        /// <param name="dataTableColumnsName"></param>
        /// <returns></returns>
        public DataTable DyadicArrayToDataTable(int[,] intDyadicArray, out string messageOut,
            params object[] dataTableColumnsName)
        {
            var returnDataTable = new DataTable();
            //验证列与所传入的字符是否相符
            if (dataTableColumnsName.Length != intDyadicArray.GetLength(1))
            {
                messageOut = "DataTable列数与二维数组列数不符，请调整列数";
                return returnDataTable;
            }
            //添加列
            for (var dataTableColumnsCount = 0;
                dataTableColumnsCount < dataTableColumnsName.Length;
                dataTableColumnsCount++)
            {
                returnDataTable.Columns.Add(dataTableColumnsName[dataTableColumnsCount].ToString());
            }
            //添加行
            for (var dyadicArrayRow = 0; dyadicArrayRow < intDyadicArray.GetLength(0); dyadicArrayRow++)
            {
                var addDataRow = returnDataTable.NewRow();
                for (var dyadicArrayColumns = 0;
                    dyadicArrayColumns < intDyadicArray.GetLength(1);
                    dyadicArrayColumns++)
                {
                    addDataRow[dataTableColumnsName[dyadicArrayColumns].ToString()] =
                        intDyadicArray[dyadicArrayRow, dyadicArrayColumns];
                }
                returnDataTable.Rows.Add(addDataRow);
            }
            //返回提示与DataTable
            messageOut = "DataTable成功转换";
            return returnDataTable;
        }

Oben Es handelt sich um eine Operationsmethode zum Konvertieren eines Integer-Arrays in eine Datentabelle. Für die Konvertierung anderer Typen wie Bytes, Gleitkomma und anderer Typen müssen Sie lediglich die entsprechenden Parameter ändern Entsprechende Typen werde ich hier nicht näher vorstellen.

Schauen wir uns als Nächstes das relevante Wissen zum „Untergrenzen-Nicht-Null-Array“ genauer an:

Da das Untergrenzen-Nicht-Null-Array hinsichtlich der Leistung nicht besser optimiert wurde , es wird im Allgemeinen nicht verwendet. Wenn Ihnen der Leistungsverlust egal ist oder Sie eine sprachübergreifende Portierung benötigen, können Sie die Verwendung eines Arrays ungleich Null in Betracht ziehen. Das Konzept des „Untergrenzen-Nicht-Null-Arrays“ wird nicht eingeführt, wie der Name schon sagt.

Verwenden Sie zum Erstellen in C# die Methode CreateInstance() von Array. Diese Methode verfügt über mehrere Überladungen, mit denen Sie den Array-Elementtyp, die Array-Dimension, die Untergrenze jeder Dimension und die Anzahl der Elemente in jeder Dimension angeben können.

Wenn Sie CreateInstance() aufrufen, weisen Sie dem Array Speicher zu, speichern Sie die Parameterinformationen im Overhead-Teil des Array-Speichers und geben Sie dann einen Verweis auf das Array zurück.

Als nächstes werfen wir einen Blick auf den zugrunde liegenden Implementierungscode dieser Methode:

[System.Security.SecuritySafeCritical]  // auto-generated 
        public unsafe static Array CreateInstance(Type elementType, int length)
        { 
            if ((object)elementType == null)
                throw new ArgumentNullException("elementType");
            if (length < 0)
                throw new ArgumentOutOfRangeException("length", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum")); 
            Contract.Ensures(Contract.Result<Array>() != null);
            Contract.Ensures(Contract.Result<Array>().Length == length); 
            Contract.Ensures(Contract.Result<Array>().Rank == 1); 
            Contract.EndContractBlock();
  
            RuntimeType t = elementType.UnderlyingSystemType as RuntimeType;
            if (t == null)
                throw new ArgumentException(Environment.GetResourceString("Arg_MustBeType"),"elementType");
            return InternalCreate((void*)t.TypeHandle.Value,1,&length,null); 
        }

Nachdem Sie den obigen Code gesehen haben, sollten Sie ein allgemeines Verständnis für die Erstellung einer Basis ungleich Null haben Werfen wir einen genaueren Blick auf den zugrunde liegenden Code der Consideres()-Methode:

public static void Ensures(bool condition)
        {
            AssertMustUseRewriter(ContractFailureKind.Postcondition, "Ensures"); 
        }

[SecuritySafeCritical]
        static partial void AssertMustUseRewriter(ContractFailureKind kind, String contractKind) 
        {
            if (_assertingMustUseRewriter) 
                System.Diagnostics.Assert.Fail("Asserting that we must use the rewriter went reentrant.", "Didn't rewrite this mscorlib?"); 
            _assertingMustUseRewriter = true;
            Assembly thisAssembly = typeof(Contract).Assembly;  
            StackTrace stack = new StackTrace(); 
            Assembly probablyNotRewritten = null;
            for (int i = 0; i < stack.FrameCount; i++) 
            { 
                Assembly caller = stack.GetFrame(i).GetMethod().DeclaringType.Assembly;
                if (caller != thisAssembly) 
                {
                    probablyNotRewritten = caller;
                    break;
                } 
            }
  
            if (probablyNotRewritten == null) 
                probablyNotRewritten = thisAssembly;
            String simpleName = probablyNotRewritten.GetName().Name; 
            System.Runtime.CompilerServices.ContractHelper.TriggerFailure(kind, Environment.GetResourceString("MustUseCCRewrite", contractKind, simpleName), null, null, null);
 
            _assertingMustUseRewriter = false;
        }

Es gibt keine ausführliche Einführung in die Erstellungsmethode eines Nicht-Null-Basisarrays Um es zu verwenden, können Sie die entsprechende Version entsprechend der bereitgestellten Methodenüberladung auswählen.