C# ArrayList.TrimToSize方法代码示例

 public MemberRoles(string member, string role)
 {
     _Member = member;
     _Roles = new ArrayList();
     _Roles.Add(role);
     _Roles.TrimToSize();
 }

        /// <summary>
        /// Gets a list of NFS config files (Nfs*.xml;Nfs*.config) from AppDomain.CurrentDomain.BaseDirectory including sub-directories
        /// </summary>
        /// <param name="returnPath">should the string[] contain the path to each file</param>
        /// <returns>a string array of file names optionally including their paths</returns>    
        public static string[] GetNFSConfigFilesInBaseDirectory(bool returnPath)
        {
            ArrayList configFiles = new ArrayList();
            configFiles.AddRange(GetFileListInBaseDirectory("Nfs*.xml", returnPath));
            configFiles.AddRange(GetFileListInBaseDirectory("Nfs*.config", returnPath));
            configFiles.TrimToSize();

            return (string[]) configFiles.ToArray(typeof (string));
        }

	public ArrayList pop_all_since_marker() {
		ArrayList result = new ArrayList();
		object o = pop();
		while (o != this.MARKER) {
			result.Add(o);
			o = pop();
		}
		result.TrimToSize();
		result.Reverse();
		return result;
	}

        //分割函数开始
        public static string[] split(string strinput, string sp)
        {
            string tmp="";
            int strlen=0, splen=0;
            int found=0;
            string[] rt = null;
            try
            {
                if (strinput == null || sp == null || strinput.Length == 0 || sp.Length == 0)
                    return null;

                //初始化一个数组列表(当做动态数组)
                ArrayList tmp3 = new ArrayList();
                strlen = strinput.Length;
                splen = sp.Length;
                for (int i = 0; i < splen; i++)
                {
                    //查找分隔符
                    found = strinput.IndexOf(sp, i);
                    if (found >= 0)
                    {
                        tmp = "";
                        //取分隔符前的字符串
                        tmp = strinput.Substring(i, found - i);
                        //添加到数组列表
                        tmp3.Add(tmp);
                        i = found + splen - 1;
                    }
                    else
                    {
                        string tmp2 = "";
                        //取最后的字符串
                        tmp2 = strinput.Substring(i);
                        if (tmp2 != "")
                            tmp3.Add(tmp2);
                        break;
                    }
                }

                //将动态数组的维数设置成实际存在的元素个数，因为数组列表是以16的倍数递增维数的
                tmp3.TrimToSize();
                //转换数组列表为字符串数组，并返回。
                rt = (string[])tmp3.ToArray(typeof(String));
                tmp3.Clear();
            }
            catch (Exception e)
            {
                //Console.WriteLine("{0}", e.Message);
                throw e;
            }
            return rt;
        }

        static void Main(string[] args)
        {
            ArrayList al = new ArrayList();
            al.Add("Paris");
            al.Add("Ottowa");
            al.AddRange(new string[] { "Rome", "Tokyo", "Tunis", "Canberra" });

            Console.WriteLine("Count:    {0}", al.Count);
            Console.WriteLine("Capacity: {0}", al.Capacity);

            Console.WriteLine("Print values using foreach");
            PrintValues(al);
            Console.WriteLine("Print values using IEnumerator");
            PrintValuesByEnumerator(al);

            // Get second item in list as string
            string str = (string)al[1];    // need to cast, would also unbox if stored type was value type
            Console.WriteLine("al[1] = {0}", str);

            // Get first three items
            ArrayList firstThree = al.GetRange(0, 3);
            PrintValues(firstThree);

            // Remove next two
            al.RemoveRange(3, 2);
            PrintValues(al);

            // Get, insert and remove
            object itemOne = al[1];
            al.Insert(1, "Moscow");
            al.RemoveAt(2);
            PrintValues(al);

            // Sort
            al.Sort();
            PrintValues(al);

            // Search
            int targetIndex = al.BinarySearch("Moscow");
            Console.WriteLine("Index of Moscow: {0}", targetIndex);

            // Trim capacity
            al.TrimToSize();
            Console.WriteLine("Count:    {0}", al.Count);
            Console.WriteLine("Capacity: {0}", al.Capacity);

            // Creates a new ArrayList with five elements and initialize each element with a value.
            ArrayList al2 = ArrayList.Repeat("Boston", 5);   // static method
            PrintValues(al2);
        }

        //Main_7_9_3
        //˵��ArrayList�������Ƕ�̬��
        public static void Main_7_9_3()
        {
            //��ʼ��arrs����Ϊ2
            ArrayList arrs = new ArrayList(2);

            arrs.Add(1);
            arrs.Add(2);
            arrs.Add(3);

            Console.WriteLine("��ǰ������{0}", arrs.Capacity);         //���Ϊ4

            arrs.TrimToSize();
            Console.WriteLine("ѹ�����������{0}", arrs.Capacity);  //���Ϊ3
        }

        public void TestTrimToSizeBasic()
        {
            //--------------------------------------------------------------------------
            // Variable definitions.
            //--------------------------------------------------------------------------
            ArrayList arrList = null;

            string[] strHeroes =
            {
                "Green Arrow",
                "Atom",
                "Batman",
                "Steel",
                "Superman",
                "Wonder Woman",
                "Hawkman",
                "Flash",
                "Aquaman",
                "Green Lantern",
                "Catwoman",
                "Huntress",
                "Robin",
                "Captain Atom",
                "Wildcat",
                "Nightwing",
                "Ironman",
                "SpiderMan",
                "Black Canary",
                "Thor",
                "Cyborg",
                "Captain America",
            };

            //
            // Construct array list.
            //
            arrList = new ArrayList((ICollection)strHeroes);

            //
            // []  Verify TrimToSize.
            //
            // Set capacity greater than the size of the ArrayList.
            arrList.Capacity = 2 * arrList.Count;
            Assert.True(arrList.Capacity > arrList.Count);

            // Verify TrimToSize
            arrList.TrimToSize();
            Assert.Equal(arrList.Count, arrList.Capacity);
        }

 /// <summary>
 ///  Factory method. Creates ScatterViewItemViews of items out from given ls
 /// </summary>
 /// <param name="ls"></param>
 /// <param name="deviceName"></param>
 /// <param name="startingPosition"></param>
 /// <returns></returns>
 public ScatterViewItem[] createFileList(ArrayList ls, String deviceName)
 {
     ls.TrimToSize();
     ScatterViewItem[] items = new ScatterViewItem[ls.Count];
     for (int i = 0; i < ls.Count; i++)
     {
         IndexObject item = ls[i] as IndexObject;
         ScatterViewItem temp = this.getItemView(item, deviceName);
         if (temp != null)
         {
             items[i] = temp;
         }
     }
         return items;
 }

        private static IIDConvertor[] GetConvertorInstances()
        {
            Assembly source = Assembly.GetAssembly(typeof(IIDConvertor));
            if ( source == null ) return new IIDConvertor[] { new Inferis2IDConvertor() };

            // Look for IIDConvertor classes
            ArrayList list = new ArrayList();
            IEnumerator iter = source.GetExportedTypes().GetEnumerator();
            while ( iter.MoveNext() ) {
                if ( ((Type)iter.Current).GetInterface( typeof(IIDConvertor).Name ) != null ) {
                    list.Add( System.Activator.CreateInstance(((Type)iter.Current)) );
                }
            }

            // Assign result
            IIDConvertor[] result = new IIDConvertor[list.Count];
            list.TrimToSize();
            list.CopyTo( result, 0 );
            return result;
        }

		public TemplateMappingConfig(XmlNode section)
		{
			foreach (XmlElement mapElement in section.SelectNodes("map"))
			{
				string templateName = mapElement.GetAttribute("templateName");
				ArrayList conds = new ArrayList(5);

				foreach (XmlElement mapConditions in mapElement.SelectNodes("*"))
					switch (mapConditions.Name)
					{
						case "regexMatch": 
							conds.Add(new RegexTemplateMappingCondition(mapConditions));
							break;
						default:
							throw new ConfigurationException("Map condition not recognized: " + mapConditions.Name, mapConditions);
					}

				conds.TrimToSize();
				maps.Add(templateName, conds);
			}
		}

        static void Main(string[] args)
        {
            ArrayList nomes = new ArrayList();

            nomes.Add("adão");
            nomes.Add("eva");
            nomes.Add("caim");
            nomes.Add("abel");
            nomes.Add(42);

            foreach (var item in nomes)
            {
                Console.WriteLine(item);
            }

            var numeros = new ArrayList { 1, 2, 3, 45 };

            int soma = 0;

            foreach (var item in numeros)
            {
                soma += (int)item;
            }

            Console.WriteLine(soma);

            numeros.Reverse();

            numeros.Sort();

            Console.WriteLine(nomes.Count);
            Console.WriteLine(nomes.Capacity);

            nomes.TrimToSize();

            Console.WriteLine(nomes.Capacity);

            Console.ReadKey();
        }

		public void TrimToSize ()
		{
			ArrayList al1 = new ArrayList ();
		// Capacity is 0 under 2.0
		int capacity = 4;
			int size = capacity / 2;
			for (int i = 1; i <= size; i++) {
				al1.Add ('?');
			}
			al1.RemoveAt (0);
			al1.TrimToSize ();
			Assert.AreEqual (size - 1, al1.Capacity, "no capacity match");

			al1.Clear ();
			al1.TrimToSize ();
			Assert.AreEqual (capacity, al1.Capacity, "no default capacity");
		}

        private void CreateFromNameAndManifests (ApplicationIdentity applicationIdentity, string[] manifestPaths)
        {
            if (applicationIdentity == null) 
                throw new ArgumentNullException("applicationIdentity");
            if (manifestPaths == null) 
                throw new ArgumentNullException("manifestPaths"); 
            Contract.EndContractBlock();
 
            _applicationIdentity = applicationIdentity;

            // ISSUE - need validation on manifestPaths
 
            IEnumDefinitionIdentity idenum = _applicationIdentity.Identity.EnumAppPath();
 
            _manifests = new ArrayList(DefaultComponentCount); 
            _manifestPaths = new String[manifestPaths.Length];
 
            IDefinitionIdentity[] asbId = new IDefinitionIdentity[1];
            int i=0;
            while (idenum.Next(1, asbId) == 1)
            { 
                ICMS cms = (ICMS) IsolationInterop.ParseManifest(manifestPaths[i], null, ref IsolationInterop.IID_ICMS);
 
                if (IsolationInterop.IdentityAuthority.AreDefinitionsEqual(0, cms.Identity, asbId[0])) 
                {
                    _manifests.Add(cms); 
                    _manifestPaths[i]=manifestPaths[i];
                }
                else
                { 
#if ISOLATION_IN_MSCORLIB
                    throw new ArgumentException(Environment.GetResourceString("Argument_IllegalAppIdMismatch")); 
#else 
                    throw new ArgumentException("Application Identity does not match identity in manifests");
#endif 
                }
                i++;
            }
            if (i!=manifestPaths.Length) 
            {
#if ISOLATION_IN_MSCORLIB 
                throw new ArgumentException(Environment.GetResourceString("Argument_IllegalAppId")); 
#else
                throw new ArgumentException("Application Identity does not have same number of components as manifest paths"); 
#endif
            }
            _manifests.TrimToSize();
            if (_manifests.Count <= 1) 
            {
#if ISOLATION_IN_MSCORLIB 
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidAppId")); 
#else
                throw new ArgumentException("Invalid identity: no deployment/app identity specified"); 
#endif
            }

            _definitionIdentities = null; 
            _actContext = null;
            _form = ContextForm.Loose; 
            _appRunState = ApplicationStateDisposition.Undefined; 

#if ISOLATION_IN_MSCORLIB 
            Contract.Assert(_manifests.Count == 2, "An application must have exactly 1 deployment component and 1 application component in Whidbey");
#endif
        }

		//funcao que retorna um arraylist com todas as linhas marcadas como modified, added e deleted provenientes do dataset principal
		public ArrayList getAlteracoes(DataSet ds, ArrayList sortedTables)
		{
			long start = 0;
			start = DateTime.Now.Ticks;

			DataTable dt = null;
			ArrayList changedRowsArrayList = new ArrayList();

			DataSet gisaBackup = new DataSet();
            gisaBackup.EnforceConstraints = false;
			gisaBackup.CaseSensitive = true;

			//processamento efectuado tabela a tabela (o array resultante desta operação já vai ordenado para o save de linhas marcadas como added e deleted)
			foreach (object o in sortedTables)
			{
				dt = GisaDataSetHelper.GetInstance().Tables[((TableDepthOrdered.tableDepth)o).tab.TableName];
				//so prossegue a operação se existir alguma linha alterada
				if (dt.Select("", "", DataViewRowState.ModifiedOriginal | DataViewRowState.Added | DataViewRowState.Deleted).Length > 0)
				{
					//array de suporte onde vao ser guardadas as linhas marcadas como modified e added
					ArrayList modif = new ArrayList();

					if (! (gisaBackup.Tables.Contains(dt.TableName)))
						gisaBackup.Tables.Add(dt.Clone());

					//por cada linha modificada verifica se foi realmente alterada; se sim, adiciona-se ao array
					DataRow[] rows = dt.Select("", "", DataViewRowState.ModifiedOriginal);
					foreach (DataRow dr in rows)
					{
						if (! (isModifiedRow(dr)))
							dr.AcceptChanges();
						else
						{
							modif.Add(dr);
							gisaBackup.Tables[dt.TableName].ImportRow(dr);
						}
					}

					ArrayList add = new ArrayList();
					//adicionar as linhas marcadas como added ao array
					foreach (DataRow dr in dt.Select("", "", DataViewRowState.Added))
					{
						add.Add(dr);
						gisaBackup.Tables[dt.TableName].ImportRow(dr);
					}

					//adicionar as linhas marcadas como deleted ao array
					ArrayList del = new ArrayList();
					foreach (DataRow dr in dt.Select("", "", DataViewRowState.Deleted))
					{
						del.Add(dr);
						gisaBackup.Tables[dt.TableName].ImportRow(dr);
					}

					//adiciona uma tabela com as respectivas linhas alteradas ao arraylist que mantem a lista de todas as linhas alteradas
					add.TrimToSize();
					modif.TrimToSize();
					del.TrimToSize();

					if (add.Count > 0 || modif.Count > 0 || del.Count > 0)
					{
						changedRowsArrayList.Add(new changedRows(dt.TableName, add, modif, del));
						mGisaBackup = gisaBackup;
					}
				}
			}
			Debug.WriteLine("<<getAlteracoes>>: " + new TimeSpan(DateTime.Now.Ticks - start).ToString());
			return changedRowsArrayList;
		}

	public void TestTrimToSize() {
		{
			bool errorThrown = false;
			try {
				ArrayList al1 = 
					ArrayList.ReadOnly(new ArrayList());
				al1.TrimToSize();
			} catch (NotSupportedException) {
				errorThrown = true;
			}
			Assert("trim read only error not thrown", 
			       errorThrown);
		}
		{
			ArrayList al1 = new ArrayList();
			int capacity = al1.Capacity;
			int size = capacity / 2;
			for (int i = 1; i <=size; i++) {
				al1.Add('?');
			}
			al1.RemoveAt(0);
			al1.TrimToSize();
			AssertEquals("no capacity match", 
				     size - 1, al1.Capacity);

			al1.Clear();
			al1.TrimToSize();
			AssertEquals("no default capacity", 
				     capacity, al1.Capacity);
		}
	}