Pouvez-vous la Liste des appels(T) placé à l'intérieur d'une autre méthode, comment initier Liste(T)?

Im nouveau à la programmation et donc cela peut être une question idiote mais je me demandais si vous pouvez placer un List<T> à l'intérieur d'une méthode et d'y accéder et de le modifier à partir de l'extérieur de cette méthode?

Comment instancier la List<T> classe pour être en mesure d'accéder et de modifier partir d'une autre classe? Peut-être que je cantt même instancier la liste de cette façon.

Voici mon code contenant le lancement de la liste:

public void MyMethod()
{
    List<Customer> newCustomer = new List<Customer>
    { 
       new Customer
       {
           Name="A",                   //Name and Telephone are properties.
           Telephone="02-333444"
       },
       new Customer
       {
            Name="B",
            Telephone="03-444555"
       },
       new Customer
       {
           Name="D",
           Telephone="03-444555"
       },
    };
}

Si je veux accéder et d'ajouter ou de supprimer des éléments de la liste à partir de l'extérieur de cette méthode que dois-je faire? J'ai essayé plusieurs choses et pourrait vraiment utiliser des suggestions? Par exemple, je veux utiliser newCustomer.Add(...); quelque part ailleurs dans le code.

Toute suggestion serait utile.

InformationsquelleAutor user1153537 | 2012-01-17

.net-4.0 c#visual-studio-2010

Vous pouvez retourner la liste que vous avez créé à partir de votre méthode:

public List<Customer> MyMethod() 
{

    List<Customer> newCustomer = new List<Customer>
    { 
       new Customer
       {
       Name="A",                   //Name and Telephone are properties.
       Telephone="02-333444"
       },

       new Customer
       {
       Name="B",
       Telephone="03-444555"
       },
       new Customer
       {      

       Name="D",
       Telephone="03-444555"
       },

    };

    return newCustomer;
}

Avis que j'ai changé de type de retour de vide à List<Customer> puis à la fin de la fonction renvoyée votre liste générée (return newCustomer).

Lorsque vous appelez votre méthode à partir de l'endroit où vous serez en mesure d'obtenir la liste retournée comme ceci :

List<Customer> customerList = MyMethod();

Ou si l'extérieur de la classe:

MyClass instanceOfClass = new MyClass();
List<Customer> customerList = instanceOfClass .MyMethod();

C'est les fondamentaux de la programmation, je pense que vous devriez lire quelques-uns des principes de base avant de s'engager trop loin dans le développement.

InformationsquelleAutor Lloyd Powell

@ThePower réponse est la bonne.

De toute façon, vous pouvez utiliser une autre solution: définissez cette variable à l'intérieur de votre classe, afin de les rendre accessibles à partir de chaque méthode à l'intérieur de cette classe:

public class Foo 
{
    private List<Customer> newCustomer = new List<Customer>();
    public void MyMethod() 
    {
        newCustomer.Add(...); 
    }
}

public class Foo 
{
    private List<Customer> newCustomer = null;
    public Foo()
    {
        newCustomer = new List<Customer>
        { 
                  new Customer
                  {
                        Name="A",                   //Name and Telephone are properties.
                      Telephone="02-333444"
                  },
                  new Customer
                  {
                        Name="B",
                        Telephone="03-444555"
                  },
                  new Customer
                  {
                        Name="D",
                      Telephone="03-444555"
                  },
             };
    }
    public void MyMethod() 
    {
        newCustomer.Add(...); 
    }
}

Les bons points, je suppose qu'il s'agit de l'objet et la portée de la fonctionnalité.

InformationsquelleAutor Marco

Vous avez besoin pour permettre à un autre code pour accéder à la référence à la List<T> objet. Vous pouvez soit les exposer comme une propriété à l'intérieur de votre classe, ou de retour à partir de la méthode. En passant par la dernière option et à l'aide de votre exemple ci-dessus, vous pouvez modifier votre méthode à ressembler à quelque chose comme:

public List<Customer> MyMethod()
{
    List<Customer> newCustomer = new List<Customer>
    { 
           new Customer
           {
           Name="A",                   //Name and Telephone are properties.
           Telephone="02-333444"
           },

           new Customer
           {
           Name="B",
           Telephone="03-444555"
           },
           new Customer
           {
           Name="D",
           Telephone="03-444555"
           },
    };

    return newCustomer;
}

Et puis vous pouvez accéder à l'aide:

//... some other code ...

//SomeClass contains the MyMethod()
var someClass = new SomeClass();

List<Customer> customers = someClass.MyMethod();
customers.Add(new Customer());

Merci pour les suggestions!

InformationsquelleAutor Samuel Slade

Vous devez retourner la Liste à partir de la méthode:

public List<Customer> MyMethod() {
    List<Customer> newCustomer = new List<Customer>
    { 
        new Customer
        {
            Name="A",                   //Name and Telephone are properties.
           Telephone="02-333444"
        },
        new Customer
        {
            Name="B",
            Telephone="03-444555"
        },
        new Customer
        {
            Name="D",
           Telephone="03-444555"
        },
    };
    return newCustomer;
}

Maintenant de l'extérieur de cette méthode, vous pouvez effectuer les opérations suivantes pour accéder à votre liste:

List<Customer> customers = MyMethod();

Merci pour toutes les suggestions! Va les essayer!

InformationsquelleAutor Carlito

Vous avez besoin pour stocker la liste quelque part en dehors de la méthode (en général dans un domaine de votre classe)

class MyClass
{
    private List<Customer> _customers = CreateCustomerList();

    public List<Customer> CreateCustomerList()
    {

        List<Customer> newCustomer = new List<Customer>
        { 
           new Customer
           {
           Name="A",                   //Name and Telephone are properties.
           Telephone="02-333444"
           },

           new Customer
           {
           Name="B",
           Telephone="03-444555"
           },
           new Customer
           {
           Name="D",
           Telephone="03-444555"
           },

        };
    }

    public void AddCustomer(Customer customer)
    {
        _customers.Add(customer);
    }

}

InformationsquelleAutor Thomas Levesque

Vous pouviez retourner la nouvelle liste de clients à partir de la méthode:

public List<Customer> MyMethod()
{

    List<Customer> newCustomer = new List<Customer>

    { 
       new Customer
       {
           Name="A",                   //Name and Telephone are properties.
           Telephone="02-333444"
       },

       new Customer
       {
           Name="B",
           Telephone="03-444555"
       },
       new Customer
       {
           Name="D",
           Telephone="03-444555"
       }
    };

    return newCustomer;
}

Puis d'appeler la méthode avec:

List<Customer> myList = MyMethod();

Vous aurez alors accès à l'objet parent et d'être en mesure de le passer en paramètre dans d'autres méthodes. Le thème général de variables disponibles, créés et détruits dans le code est appelé "champ d'application" si vous souhaitez Google plus d'infos sur le sujet.

InformationsquelleAutor Adrian Thompson Phillips

0

Pas directement, ce qui est une sorte de point d'avoir de l'encapsulation.

Vous pouvez cependant:
1. Définir une variable en dehors de la méthode à partir de l'intérieur de la méthode.
2. Retour la liste.
3. Passer la liste à une autre méthode que vos appels de méthode.
4. Avoir la liste capturé par un délégué.
InformationsquelleAutor Jon Hanna

Vous devez vous connecter pour publier un commentaire.