use field of generic list into class method

I have several generic lists which have different quantity of properties, but all of them have some
common field names, for instance, id, port, name, and so on.

I have something like snippet.

public bool LookPortName<T>(List<T> list, string id, ref string port, ref string name)  
{
    int index;  
    try
    {    
      //It checks if found id into generic list.  
      if (index == -1) return false;  										
      //Get portfolio abbreviation.  											
      port = list[index].portfolio.Trim();  
      //Get portfolio complete name.  
      name = list[index].portName.Trim();  	
      return true;  
    }
    catch
    {
      //Other code
    }
}  

All lists have common files such as "id", "portfolio" and "portName" but they doesn't exist into generic
method.

Is it possible to use fields of generic list into generic method?

Someone who knows how to solve my question with a clear code example?

Thanks a lot!

Use an interface

// modify interface to fit your program
interface IPortfolio {
    public string Id { get; set; }
    public string portfolio { get; set; }
    public string portName { get; set; }
}

and add where T : IPortfolio to the method declaration
This allows you to use T as if it were an IPortfolio.

public bool LookPortName<T>(List<T> list, string id, ref string port, ref string name) where T : IPortfolio

Then, have any class which needs to be passed into the method implement the interface

Note that you can't just use an interface because you wouldn't be able to pass a list.

More Info

The common approach is to extract all common properties/methods into interface (or abstract class), implement this interface in the corresponding types (or inherit from the class) and then introduce the generic constraint limiting the allowed types to the interface (or abstract class):

public bool LookPortName<T>(List<T> list, string id, ref string port, ref string name)  
   where T : IHaveFields
{
    T x = ...;
    x.SomePropOnInterface;
}  

Like in @AspectOfTheNoob answer you can create interface, implement it in your items classes, and use it in constrain of T in LookPortName method .

public interface IPortInfo {
    string id { get; }
    string portfolio { get; }
    string portName { get; }
}
public class SomeItemPortInfo : IPortInfo {
    public string id { get; set; }
    public string portfolio { get; set; }
    public string portName { get; set; }
}

public bool LookPortName<T>(List<T> list, string id, ref string port, ref string name)
    where T : IPortInfo {

You can also build base class and add constrain or use it directly as type of argument.

public abstract class BasePortInfo {
    public virtual string id { get; set; }
    public virtual string portfolio { get; set; }
    public virtual string portName { get; set; }
}

public class SomeItemPortInfo : BasePortInfo {
}

If you need, you can declare this method as extension of List

public static class PortInfoListExtensions {
    public static bool TryGetPortInfo<T>(this List<T> list, string id, out string port, out string name) where T : BasePortInfo {        
        port = null; name = null;
        try {
            int index = list.FindIndex(i => i.id == id);
            if(index < 0)
                return false;
            //Get portfolio abbreviation.                                             
            port = list[index].portfolio.Trim();
            //Get portfolio complete name.  
            name = list[index].portName.Trim();
            return true;
        } catch {
            return false;
            //Other code
        }
    }
}

And call it, for example like here:

if(listOfPortInfo?.TryGetPortInfo(id, out string port, out string name) ?? false) {
    //if list contains id, do something with port and name....            
}

You can also test type of argument and use reflection, if you can't add inteface or change class definitions.

Another option here is to assign to dynamic --
which

> doesn’t require explicit cast operations at compile time, because it identifies the type at run time only

public class GenericListDemoProgram
{
    internal static async Task Main(string[] args)
    {
        await Task.Yield();
        var port = string.Empty;
        var name = string.Empty;

        if (LookPortName(new[]
        {
            new {id = "p1", portfolio = "profolio1", portName = "8123"},
            new {id = "p2", portfolio = "profolio2", portName = "8122"},
            new {id = "p3", portfolio = "profolio3", portName = "8121"},
            new {id = "p4", portfolio = "profolio4", portName = "8120"},
        }.ToList(), 3, ref port, ref name))
        {
            Console.WriteLine($"port:{port}; name:{name}");
        }
    }

    public static bool LookPortName<T>(List<T> list, int index, ref string port, ref string name)
    {
        try
        {
            //It checks if found id into generic list.  
            if (index == -1) return false;

            dynamic? item = list[index];

            if (item == null) return false;


            //Get portfolio abbreviation.                                             
            port = item.portfolio.Trim();
            //Get portfolio complete name.  
            name = item.portName.Trim();
            return true;
        }
        catch (Exception ex) { 
            //Other code
            return false;
        }
    }
}

result

note the Dynamic Language Runtime (DLR) is also a consideration here -- in respect to interoperation (though that may not be an aspect of your work)