Создать список массивов в C#

Question

У меня возникла проблема с созданием списка массивов в C#. Можете ли вы мне помочь. Мне нужно создать список массива, чтобы удалить все трубы, которые имеют длину ниже 19.

namespace ConsoleApplication1 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      ArrayList lstPipeTypes = new ArrayList(); 

      lstPipeTypes.Add(new PipesList("PVC Pipes")); 
      ((PipesList)lstPipeTypes[0]).Pipes.Add(new Pipe("The blue pipe", 12)); 
      ((PipesList)lstPipeTypes[0]).Pipes.Add(new Pipe("The red pipe", 15)); 
      ((PipesList)lstPipeTypes[0]).Pipes.Add(new Pipe("The silver pipe", 6)); 
      ((PipesList)lstPipeTypes[0]).Pipes.Add(new Pipe("The green pipe", 52)); 

      lstPipeTypes.Add(new PipesList("Iron Pipes")); 
      ((PipesList)lstPipeTypes[1]).Pipes.Add(new Pipe("The gold pipe", 9)); 
      ((PipesList)lstPipeTypes[1]).Pipes.Add(new Pipe("The orange pipe", 115)); 
      ((PipesList)lstPipeTypes[1]).Pipes.Add(new Pipe("The pink pipe", 1)); 

      lstPipeTypes.Add(new PipesList("Chrome Pipes")); 
      ((PipesList)lstPipeTypes[2]).Pipes.Add(new Pipe("The grey pipe", 12)); 
      ((PipesList)lstPipeTypes[2]).Pipes.Add(new Pipe("The black pipe", 15)); 
      ((PipesList)lstPipeTypes[2]).Pipes.Add(new Pipe("The white pipe", 19)); 
      ((PipesList)lstPipeTypes[2]).Pipes.Add(new Pipe("The brown pipe", 60)); 
      ((PipesList)lstPipeTypes[2]).Pipes.Add(new Pipe("The peach pipe", 16)); 


      RemoveTheSmallPipes(lstPipeTypes); 
     } 


     public static ArrayList RemoveTheSmallPipes(ArrayList lstPipeTypes) 
     { 

      //should remove all pipes that have lengths lower than 19. 

      return lstPipeTypes; 

     } 
    } 

    class PipesList 
    { 
     public string pipeType; 
     public ArrayList Pipes; 

     public PipesList(string newBoxType) 
     { 
      pipeType = newBoxType; 
      Pipes = new ArrayList(); 
     } 
    } 

    class Pipe 
    { 
     public string name; 
     public float length; 

     public Pipe(string newName, float newLength) 
     { 
      this.name = newName; 
      this.length = newLength; 
     } 
    } 


} 

Я создал два класса, называемые трубы и PipeList, а также и мне нужно поместить список массива в " RemoveTheSmallPipes ". Но теперь я смущен, чтобы написать все остальное. Пожалуйста, помогите мне, чтобы удалить все трубы, которые имеют длину ниже 19.

Answer 1

Вот ваш метод, не меняя ничего другого:

public static ArrayList RemoveTheSmallPipes(ArrayList lstPipeTypes) 
{ 

    for (int i = 0; i < lstPipeTypes.Count; i++) 
    { 
     ArrayList pipesToRemove = new ArrayList(); 
     int pipeCount = ((PipesList)lstPipeTypes[i]).Pipes.Count; 
     for (int j = 0; j < pipeCount; j++) 
     { 
      if (((Pipe)((PipesList)lstPipeTypes[i]).Pipes[j]).length < 19) 
      { 
       pipesToRemove.Add(j); 
      } 
     } 

     for (int k = 0; k < pipesToRemove.Count; k++) 
     { 
      ((PipesList)lstPipeTypes[i]).Pipes.RemoveAt((int)pipesToRemove[k]); 
     } 
    } 

    return lstPipeTypes; 
} 

Это действительно позор, Вы не можете больше ничего менять, потому что этот код не соответствует стандартам больше. Для того, чтобы показать вам разницу здесь Модифицированная C# 4.0 версия:

консоли:

static void Main(string[] args) 
{ 
    var pipeTypes = new List<PipePile>(); 

    pipeTypes.Add(new PipePile("PVC Pipes", new List<Pipe> 
     { 
      new Pipe { Name = "The blue pipe", Length = 12 }, 
      new Pipe { Name = "The red pipe", Length = 15 }, 
      new Pipe { Name = "The silver pipe", Length = 6 }, 
      new Pipe { Name = "The green pipe", Length = 52 } 
     })); 

    pipeTypes.Add(new PipePile("Iron Pipes", new List<Pipe> 
     { 
      new Pipe { Name = "The gold pipe", Length = 9 }, 
      new Pipe { Name = "The orange pipe", Length = 115 }, 
      new Pipe { Name = "The pink pipe", Length = 1 } 
     })); 

    pipeTypes.Add(new PipePile("Chrome Pipes", new List<Pipe> 
     { 
      new Pipe { Name = "The grey pipe", Length = 12 }, 
      new Pipe { Name = "The black pipe", Length = 15 }, 
      new Pipe { Name = "The white pipe", Length = 19 }, 
      new Pipe { Name = "The brown pipe", Length = 60 }, 
      new Pipe { Name = "The peach pipe", Length = 16 } 
     })); 

    // Remove all pipes with length longer than 19 
    pipeTypes.ForEach(pile => pile.Pipes.RemoveAll(pipe => pipe.Length > 19)); 
} 

Классы:

public class Pipe 
{ 
    public string Name { get; set; } 
    public float Length { get; set; } 
} 

public class PipePile 
{ 
    public string PipeType { get; set; } 
    public List<Pipe> Pipes { get; set; } 

    public PipePile(string pipeType, List<Pipe> pipes) 
    { 
     PipeType = pipeType; 
     Pipes = pipes; 
    } 

    public PipePile(): this("", new List<Pipe>()) 
    { 
    } 
} 

Как Вы можете видеть, что это совершенно разные, но гораздо более элегантный (Linq FTW:))

Answer 2

Вы можете попробовать:

for (i = 0; i < lstPipeTypes.Count; i++) { 
    ((PipesList)lstPipeTypes[i]).Pipes.remove(x => x.Length < 19);  
} 

Answer 3

Соглашаясь с комментарием об использовании списка вместо ArrayList, поэтому я изменил код чуточку (бы из изменил его больше, но хотел, чтобы он выглядел знакомым).

using System.Collections.Generic; 
using System.Linq; 

namespace ConsoleApplication1 
{ 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      IList<PipesList> lstPipeTypes = new List <PipesList>(); 

      lstPipeTypes.Add(new PipesList("PVC Pipes")); 
      (lstPipeTypes[0]).Pipes.Add(new Pipe("The blue pipe", 12)); 
      (lstPipeTypes[0]).Pipes.Add(new Pipe("The red pipe", 15)); 
      (lstPipeTypes[0]).Pipes.Add(new Pipe("The silver pipe", 6)); 
      (lstPipeTypes[0]).Pipes.Add(new Pipe("The green pipe", 52)); 

      lstPipeTypes.Add(new PipesList("Iron Pipes")); 
      (lstPipeTypes[1]).Pipes.Add(new Pipe("The gold pipe", 9)); 
      (lstPipeTypes[1]).Pipes.Add(new Pipe("The orange pipe", 115)); 
      (lstPipeTypes[1]).Pipes.Add(new Pipe("The pink pipe", 1)); 

      lstPipeTypes.Add(new PipesList("Chrome Pipes")); 
      (lstPipeTypes[2]).Pipes.Add(new Pipe("The grey pipe", 12)); 
      (lstPipeTypes[2]).Pipes.Add(new Pipe("The black pipe", 15)); 
      (lstPipeTypes[2]).Pipes.Add(new Pipe("The white pipe", 19)); 
      (lstPipeTypes[2]).Pipes.Add(new Pipe("The brown pipe", 60)); 
      (lstPipeTypes[2]).Pipes.Add(new Pipe("The peach pipe", 16)); 


      RemoveTheSmallPipes(lstPipeTypes); 
     } 


     public static IList<PipesList> RemoveTheSmallPipes(IList<PipesList> lstPipeTypes) 
     { 

      foreach (var pipesList in lstPipeTypes) 
      { 
       pipesList.Pipes = pipesList.Pipes.Where(p => p.length >= 19).ToList(); 
      } 

      return lstPipeTypes; 
     } 
    } 

    class PipesList 
    { 
     public string pipeType; 
     public IList<Pipe> Pipes; 

     public PipesList(string newBoxType) 
     { 
      pipeType = newBoxType; 
      Pipes = new List <Pipe>(); 
     } 
    } 

    class Pipe 
    { 
     public string name; 
     public float length; 

     public Pipe(string newName, float newLength) 
     { 
      this.name = newName; 
      this.length = newLength; 
     } 
    } 


} 

Я также предлагаю вам вынимая жестко значение 19, и с помощью константный или что-то, или, возможно, в качестве параметра метода.