C# and Reflection don't work twice in a row

I've a problem and I can't figured it out how to solve it.

I've a class for fetching data from a Database, in this class I've a method for a simple select * this method is called

List<T> All<T>(string tableName)

and you have to specify which resource you want to fetch, for example

All<User>("users")

And, aside from the classic SQL Reader and SQL Command, the core of the method is this

public override List<T> All<T>(string resource) 
    {
        List<T> result = new List<T>();
        using (MySqlConnection sqlConnection = new MySqlConnection(connectionString))
        {
            sqlConnection.Open();
            try
            {
                string query = "SELECT * FROM " + resource + " WHERE 1=1";
                using (MySqlCommand sqlCommand = new MySqlCommand(query, sqlConnection))
                {
                    lock (locker)
                    {
                        MySqlDataReader reader = sqlCommand.ExecuteReader();
                        if (reader.HasRows)
                        {
                            while (reader.Read())
                            {
                                T model = Activator.CreateInstance<T>();
                                Dictionary<string, object> _properties = new Dictionary<string, object>();
                                for (int i = 0; i < reader.FieldCount; i++)
                                {
                                    string property = reader.GetName(i);
                                    object value = reader.GetValue(i);
                                    _properties.Add(property, value);
                                }
                                var type = model.GetType();
                                var method = type.GetMethod("SetProperties");
                                var invoked = method.Invoke(model, new object[] { _properties });

                                result.Add(model);
                            }
                        }
                        reader.Close();
                    }
                }
            }
            catch (Exception ex)
            {
                Program.eventLogger.Add(new Event(EventType.Error, "SQL Data Providers", "Exception catched on All", ex));
            }
            finally
            {
                sqlConnection.Close();
            }
        }
        return result;
    }

Basically, based on the Type from the method header, the method will try to create an new instance of the specific type, later for each field from the query, it will fills all the attributes of the class on a temporaneous list. Once it's done it will try to call the method "SetProperties" which basically set every attributes of the class using reflection.

This is the core of SetProperties, equal for each entity:

    public virtual bool SetProperties(Dictionary<string,object> properties)
    {
        if(this.ValidateData(properties))
        {
            FillNullableAttributes(properties);
            // Iterate trough every key : value pairs in properties
            foreach (KeyValuePair<string, object> kvp in properties)
            {
                if (this.data.Contains(kvp.Key))
                {
                    var property = this.GetType().GetProperty(kvp.Key);
                    PropertyInfo propertyInfo = this.GetType().GetProperty(kvp.Key);
                    // Set the current fetched key with the given value if !null
                    if (kvp.Value != null)
                    {
                        Type fetchedType = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType;
                        object safeConversion = (kvp.Value == null || kvp.Value == DBNull.Value) ? null : Convert.ChangeType(kvp.Value, fetchedType);
                        if (propertyInfo.CanWrite)
                        {
                            propertyInfo.SetValue(this, safeConversion, null);
                        }
                    }
                }
            }
            return true;
        }
        return false;
    }

In conclusion the result, which is a list, will be returned and the specific Entity will have its own BindingList filled. The binding list, for each entity is described as follow:

public static BindingList<Seller> items = new BindingList<Seller>();

This code works fine, even if there's a lot of space for improvements I know, but if I called it twice like this:

User.items = new BindingList<User>(provider.All<User>("users"));
User.items = new BindingList<User>(provider.All<User>("users"));

The second list will be filled by empty entities, the counting of the will be correct but they will be empties... and that shouldn't occurs.

The only thing that I figured it out, from the debugging, is that on the second call

var invoked = method.Invoke(model, new object[] { _properties });

invoked is set to false.