C# StringList.Add方法代码示例

        /// <summary>
        /// Constructor
        /// </summary>
        public CustomViewEngine(params string[] additionalLocations)
        {
            StringList viewLocations = new StringList();
            viewLocations.Add("~/Views/{1}/{0}.cshtml");
            viewLocations.Add("~/Views/Shared/{0}.cshtml");
            viewLocations.AddRange(additionalLocations);

            this.PartialViewLocationFormats = viewLocations.ToArray();
            this.ViewLocationFormats = viewLocations.ToArray();
        }

 public static EntityMemberMask Create(EntityInfo entity, string propertiesOrGroups)
 {
     var invalidNames = new StringList();
       var mask = new EntityMemberMask(propertiesOrGroups, entity);
       var props = propertiesOrGroups.SplitNames(',', ';');
       foreach (var name in props) {
     //first try member
     if (string.IsNullOrWhiteSpace(name))
       continue;
     var grp = entity.GetPropertyGroup(name);
     if (grp != null) {
       foreach (var m in grp.Members)
     mask.Set(m);
       continue;
     }
     var member = entity.GetMember(name);
     if (member != null) {
       mask.Set(member);
       continue;
     }
     //name is invalid
     invalidNames.Add(name);
       }
       if (invalidNames.Count > 0)
     Util.Throw("Properties/subgroups [{0}] not found in entity {1}.", string.Join(",", invalidNames), entity.EntityType);
       return mask;
 }

 public override IList<string> GetFirsts()
 {
     var firsts = new StringList();
     foreach (var t in LineTerminators)
         firsts.Add(t.ToString());
     return firsts;
 }

        public string GetValue()
        {
            StringTable table = new StringTable();

            //table.Add("LimitType", LimitType.ToString());
            table.Add("LimitType", ((byte)LimitType).ToString());


            foreach (KeyValuePair<Guid, List<Guid>> item in ExcludeRoles)
            {

                if (item.Value != null)
                {

                    StringList roles = new StringList();
                    foreach (Guid roleID in item.Value)
                    {
                        roles.Add(roleID.ToString());
                    }

                    table.Add("ExcludeRoles-" + item.Key.ToString("N"), roles.ToString());

                }

            }

            return table.ToString();
        }

 public static string FormatSqlParameters(ICollection prms, string format = "{0}={1}", string delimiter = ", ", int maxValueLen = 50)
 {
     var sValues = new StringList();
       foreach (IDbDataParameter prm in prms)
     sValues.Add(FormatSqlParameter(prm, format, maxValueLen));
       var result = string.Join(delimiter, sValues);
       return result;
 }

 public override void Compute()
 {
     StringList list = new StringList();
     foreach (string theString in DevelopmentKit.IO.Generics.ImportStrings(_config.FileName.Absolute))
     {
         list.Add(theString);
     }
     Workspace.Store("ListOfStrings", list);
 }

        internal void Run(StringList values)
        {
            if (string.IsNullOrEmpty(Command))
            {
                return;
            }

            List<Item> items = new List<Item>();
            StringList othervalues = new StringList();

            foreach (var val in values)
            {
                ItemUri uri = ItemUri.Parse(val);
                if (uri != null)
                {
                    items.Add(Sitecore.Data.Database.GetItem(uri));
                }
                else
                {
                    othervalues.Add(val);
                }
            }

            Command command = CommandManager.GetCommand(Command);
            Debug.Assert(command != null, Command + " not found.");

            // If our command can hanlde more than one item in the context we run it once
            if (!SingleItemContext)
            {
                CommandContext cc = new CommandContext(items.ToArray());
                cc.CustomData = othervalues;
                command.Execute(cc);
            }
            //otherwise we have to generate as many commands as items
            else
            {
                if (items.Count > 0)
                {
                    foreach (var item in items)
                    {
                        CommandContext cc = new CommandContext(item);
                        command.Execute(cc);
                    }
                }
                if (othervalues.Count > 0)
                {
                    foreach (var othervalue in othervalues)
                    {
                        CommandContext cc = new CommandContext();
                        cc.CustomData = othervalue;
                        command.Execute(cc);
                    }
                }
            }
        }

 public override IList<string> GetFirsts()
 {
     StringList result = new StringList();
       result.AddRange(base.Prefixes);
       //we assume that prefix is always optional, so number can always start with plain digit
       result.AddRange(new string[] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" });
       // Python float numbers can start with a dot
       if (IsSet(TermOptions.NumberAllowStartEndDot))
     result.Add(DecimalSeparator.ToString());
       return result;
 }

        public void ToStringTest()
        {
            StringList target = new StringList();
            // empty list
            string expected = string.Empty;
            string actual = target.ToString();
            Assert.AreEqual(expected, actual);

            // 1 item in list
            target.Add("test1");
            expected = "test1";
            actual = target.ToString();
            Assert.AreEqual(expected, actual);

            // 2 items in list
            target.Add("test2");
            expected = "test1,test2"; 
            actual = target.ToString();
            Assert.AreEqual(expected, actual);
        }

        public void SetBannedSpiders(IEnumerable<string> spiderNames)
        {
            StringList bannedNames = new StringList();

            if (spiderNames != null)
            {
                foreach (string spiderName in spiderNames)
                {
                    bannedNames.Add(spiderName);
                }
            }
            m_BannedNames = bannedNames;
            m_BannedSpiders = null;
        }

 //
 public override DbCommandInfo BuildSqlInsertCommand(EntityCommand entityCommand)
 {
     const string SqlInsertTemplate = @"
     INSERT INTO {0}
       ({1})
       VALUES
     ({2});
     {3}
     ";
       bool useStoredProc = this.DbModel.Config.Options.IsSet(DbOptions.UseStoredProcs);
       var table = DbModel.LookupDbObject<DbTableInfo>(entityCommand.TargetEntityInfo, throwNotFound: true);
       var idClause = string.Empty;
       var listColumns = new List<DbColumnInfo>();
       var listValues = new StringList();
       var cmdName = ModelConfig.NamingPolicy.ConstructDbCommandName(entityCommand, table.TableName, "Insert");
       var dbCmdInfo = CreateDbCommandInfo(entityCommand, cmdName, table, DbExecutionType.NonQuery, null);
       foreach (var prm in dbCmdInfo.Parameters) {
     var col = prm.SourceColumn;
     if (!col.Flags.IsSet(DbColumnFlags.NoInsert)) {
       listColumns.Add(col);
       listValues.Add(prm.Name);
     }
     // identity
     if (col.Flags.IsSet(DbColumnFlags.Identity)) {
       if (useStoredProc)
     //append to stored proc
     idClause = string.Format("SET {0} = LAST_INSERT_ID();", prm.Name);
       else
     dbCmdInfo.PostUpdateActions.Add((conn, cmd, rec) => {
       var idCmd = conn.DbConnection.CreateCommand();
       idCmd.CommandText = "Select LAST_INSERT_ID();";
       idCmd.Transaction = conn.DbTransaction;
       var id = conn.Database.ExecuteDbCommand(idCmd, conn, DbExecutionType.Scalar); //it is decimal
       var intId = Convert.ChangeType(id, prm.SourceColumn.Member.DataType);
       rec.SetValueDirect(prm.SourceColumn.Member, intId);
     });
     }//if identity
       }
      // this.ModelConfig.Options.IsSet(DbOptions.us)
       //build SQL
       var strColumns = listColumns.GetSqlNameList();
       var strValues = string.Join(", ", listValues);
       dbCmdInfo.Sql = string.Format(SqlInsertTemplate, table.FullName, strColumns, strValues, idClause);
       return dbCmdInfo;
 }

 // For cached queries, local values are passed in closure object. The problem is that a single closure is created for a method,
 // and a query might use only some of closure values. So for each field in closure we check that it is actually used in the query we report.
 private static string FormatClosureValues(string fromExpression, string paramName, object obj)
 {
     if (obj == null)
     return paramName + "=null";
       var type = obj.GetType();
       if (!type.IsAnonymousType())
     return paramName + "=" + LoggingExtensions.ToLogString(obj);
       //Anonymous type
       var fields = type.GetFields();
       var strValues = new StringList();
       for (int i = 0; i < fields.Length; i++ ) {
     var fld = fields[i];
     var fullRefName = paramName + "." + fld.Name;
     if (fromExpression.Contains(fullRefName))
       strValues.Add(fullRefName  + "=" + LoggingExtensions.ToLogString(fld.GetValue(obj)));
       }
       return string.Join(", ", strValues);
 }

        private static void CloneTestSpecs(string rootBranch, string targetBranch, IDictionary<string, object> parameters)
        {
            if (parameters.ContainsKey(TestSpecs) && parameters[TestSpecs] != null)
            {
                var testSpecList = parameters[TestSpecs] as TestSpecList;
                if (testSpecList == null)
                {
                    return;
                }

                foreach (var spec in testSpecList)
                {
                    var assemblySpec = spec as TestAssemblySpec;
                    if (assemblySpec != null)
                    {
                        if (!string.IsNullOrEmpty(assemblySpec.TestSettingsFileName) && assemblySpec.TestSettingsFileName.StartsWith(rootBranch, StringComparison.OrdinalIgnoreCase))
                        {
                            assemblySpec.TestSettingsFileName = assemblySpec.TestSettingsFileName.Replace(rootBranch, targetBranch);
                        }
                    }

                    var metadataFileSpec = spec as TestMetadataFileSpec;
                    if (metadataFileSpec != null)
                    {
                        var modifiedTestLists = new StringList();
                        foreach (var list in metadataFileSpec.TestLists)
                        {
                            string modifiedTestList = list;
                            if (modifiedTestList.StartsWith(rootBranch, StringComparison.OrdinalIgnoreCase))
                            {
                                modifiedTestList = modifiedTestList.Replace(rootBranch, targetBranch);
                            }

                            modifiedTestLists.Add(modifiedTestList);
                        }

                        if (!string.IsNullOrEmpty(metadataFileSpec.MetadataFileName) && metadataFileSpec.MetadataFileName.StartsWith(rootBranch, StringComparison.OrdinalIgnoreCase))
                        {
                            metadataFileSpec.MetadataFileName = metadataFileSpec.MetadataFileName.Replace(rootBranch, targetBranch);
                        }
                    }
                }
            }
        }

 /// <summary>
 /// Updates Strains
 /// </summary>
 /// <param name="strains">StrainList Object</param>
 /// <returns></returns>
 public virtual StringList UpdateStrains(StrainList strains)
 {
     string source_id = GetSourceID();
     StrainMgr mgr = StrainMgr.Instance;
     if (strains == null)
     {
         StrainSearch search = StrainSearch.New();
         search.HasPhenotypeData = true;
         strains = mgr.GetStrains(search, SecurityContext.New());
     }
     StringList output = new StringList();
     foreach (Strain strain in strains)
     {
         string result;
         if (mgr.StrainHasPublications(strain.ID))
         {
             PublicationSearch pub_search = PublicationSearch.New();
             pub_search.StrainID = strain.ID;
             PublicationList pubs = PublicationMgr.Instance.GetPublications(pub_search, SecurityContext.New());
             foreach (Publication pub in pubs)
             {
                 string pubmedid = pub.ExternalReference.ExternalID;
                 result = UpdateResource(ObjectToResource(source_id, strain.HtmlName, strain.ID.ToString(), strain.StrainDescription, GetUrl("Strain") + strain.ID.ToString(), "mouse", "Mouse Strain", strain.History.CreationDate, GetGeneIDsFromStrain(strain.ID), null, pubmedid));
                 output.Add(result);
             }
         }
         else
         {
             result = UpdateResource(ObjectToResource(source_id, strain.HtmlName, strain.ID.ToString(), strain.StrainDescription, GetUrl("Strain") + strain.ID.ToString(), "mouse", "Mouse Strain", strain.History.CreationDate, GetGeneIDsFromStrain(strain.ID), null, null));
             output.Add(result);
         }
     }
     return output;
 }

        /// <summary>
        /// Get ResourceTypes
        /// </summary>
        /// <returns>StringList object</returns>
        public virtual StringList GetResourceTypesAsStringList()
        {
            try
            {
                if (webservice == null)
                    return new StringList();
                int typesCount = webservice.getResourceTypes().Length;
                dkCOIN.typeResourceType[] resourceTypes = new dkCOIN.typeResourceType[typesCount];
                resourceTypes = webservice.getResourceTypes();

                StringList resourceTypeList = new StringList();

                for (int i = 0; i < typesCount; i++)
                {
                    string resourceType = "";
                    resourceType = resourceTypes[i].name;

                    resourceTypeList.Add(resourceType);
                }

                return resourceTypeList;
            }
            catch (Exception e)
            {
                EmailErrorNotification(e.Message, "Attempting to execute StringList GetResourceTypes()");
                return null;
            }
        }