How can I find a specific item in a list? T & gt;

advertisements

My application uses a list like this:

List<MyClass> list = new List<MyClass>();

Using the Add method, another instance of MyClass is added to the list.

MyClass provides, among others, the following methods:

public void SetId(String Id);
public String GetId();

How can I find a specific instance of MyClass by means of using the GetId method? I know there is the Find method, but I don't know if this would work here?!


Use a lambda expression

MyClass result = list.Find(x => x.GetId() == "xy");


Note: C# has a built-in syntax for properties. Instead of writing Set- and Get-methods, write

private string _id;
public string Id
{
    get
    {
        return _id;
    }
    set
    {
        _id = value;
    }
}

value is a contextual keyword known only in the set accessor. It represents the value assigned to the property.

Since this pattern is often used, C# provides automatically implemented properties. They are a short version of the code above; however, the backing variable is hidden and not accessible (it is accessible from within the class in VB, however).

public string Id { get; set; }

You can simply use properties as if you were accessing a field:

var obj = new MyClass();
obj.Id = "xy";       // Calls the setter with "xy" assigned to the value parameter.
string id = obj.Id;  // Calls the getter.


Using properties, you would search for items in the list like this

MyClass result = list.Find(x => x.Id == "xy");


You can also use automatically implemented properties if you need a read-only property:

public string Id { get; private set; }

This enables you to set the Id within the class but not from outside. If you need to set it in derived classes as well you can also protect the setter

public string Id { get; protected set; }


And finally, you can declare properties as virtual and override them in deriving classes, allowing you to provide different implementations for getters and setters; just as for ordinary virtual methods.


Since C# 6.0 (Visual Studio 2015, Roslyn) you can write getter-only auto-properties with an inline initializer

public string Id { get; } = "A07"; // Evaluated once when object is initialized.

You can also initialize getter-only properties within the constructor instead. Getter-only auto-properties are true read-only properties, unlike automatically implemented properties with a private setter.

This works also with read-write auto-properties:

public string Id { get; set; } = "A07";

Beginning with C# 6.0 you can also write properties as expression-bodied members

public DateTime Yesterday => DateTime.Date.AddDays(-1); // Evaluated at each call.
// Instead of
public DateTime Yesterday { get { return DateTime.Date.AddDays(-1); } }

See: .NET Compiler Platform ("Roslyn")
         New Language Features in C# 6

Starting with C# 7.0, both, getter and setter, can be written with expression bodies:

public string Name
{
    get => _name;                                // getter
    set => _name = value;                        // setter
}

Note that in this case the setter must be an expression. It cannot be a statement. The example above works, because in C#, an assignment can be used as an expression or as a statement. The value of an assignment expression is the assigned value. The assignment itself is a side effect. This allows you to assign a value to more than one variable at once: x = y = z = 0 which is equivalent to x = (y = (z = 0)).