C#

anil150875 wrote:

graphdata

anil150875 wrote:

AWS

class GroupEntity { }
class ConfigEntity : GroupEntity { }
class DefinitionEntity : GroupEntity { }

class GroupEntity
{
    public List<ConfigEntity> ConfigEntities { get; }
}

class ConfigEntity
{
    public List<DefinitionEntity> DefinitionEntities { get; }
}

class DefinitionEntity { }

public class Parser<T> where T : GroupEntity
{
    public List<T> Data { get; set; }
    
    public void LoadDataFromFile(string fileName)
    {
        List<GroupEntity> allData = Serialization.DeSerializeObject<List<GroupEntity>>(fileName); 
        Data = allData.OfType<T>().ToList();
    }
}

private void LoadDataFromFile(string fileName)
{
    try
    {
        // Lists
        List<RuleGroupEntity> groups = new List<RuleGroupEntity>();
        List<RuleConfigurationEntity> configs = new List<RuleConfigurationEntity>();
        List<RuleDefinitionEntity> definitions = new List<RuleDefinitionEntity>();

        // Deserialize into the Groups
        groups = Serialization.DeSerializeObject<List<RuleGroupEntity>>(fileName);

        // Go through all the data and load the lists
        foreach (var group in groups)
        {
            configs.AddRange(group.RuleConfigurations);

            foreach (var config in group.RuleConfigurations)
            {
                definitions.Add(config.RuleDefinition);
            }
        }

        // Get the parameter type
        Type parameterType = typeof(T);

        // If T is Configurations, the load the Data T property with the configs list
        if (parameterType == typeof(RuleConfigurationEntity))
        {
            Data = (T)Activator.CreateInstance(typeof(T), configs); // <== Something like this is what I want.
        }
    }
    catch (Exception e)
    {
    }
}

public class Parser<T> where T : EntityBase
{
    public List<T> Data { get; set; }
    
    public void LoadDataFromFile(string fileName)
    {
        List<RuleGroupEntity> groups = Serialization.DeSerializeObject<List<RuleGroupEntity>>(fileName);
        switch (typeof(T))
        {
            case typeof(RuleGroupEntity):
            {
                Data = (List<T>)(object)groups;
                break;
            }
            case typeof(RuleConfigurationEntity):
            {
                List<RuleConfigurationEntity> configs = groups.SelectMany(g => g.RuleConfigurations).ToList();
                Data = (List<T>)(object)configs;
                break;
            }
            case typeof(RuleDefinitionEntity):
            {
                List<RuleDefinitionEntity> definitions = groups.SelectMany(g => g.RuleConfigurations).Select(c => c.RuleDefinition).ToList();
                Data = (List<T>)(object)definitions;
                break;
            }
            default:
            {
                throw new NotSupportedException($"Type '{typeof(T)}' is not supported.");
            }
        }
    }
}

public abstract class Parser<T> where T : EntityBase
{
    public List<T> Data { get; set; }
    
    public void LoadDataFromFile(string fileName)
    {
        List<RuleGroupEntity> groups = Serialization.DeSerializeObject<List<RuleGroupEntity>>(fileName);
        LoadDataFromGroups(groups);
    }
    
    protected abstract void LoadDataFromGroups(List<RuleGroupEntity> groups);
}

public class RuleGroupEntityParser : Parser<RuleGroupEntity>
{
    protected override void LoadDataFromGroups(List<RuleGroupEntity> groups)
    {
        Data = groups;
    }
}

public class RuleConfigurationEntityParser : Parser<RuleConfigurationEntity>
{
    protected override void LoadDataFromGroups(List<RuleGroupEntity> groups)
    {
        Data = groups.SelectMany(g => g.RuleConfigurations).ToList();
    }
}

public class RuleDefinitionEntityParser : Parser<RuleDefinitionEntity>
{
    protected override void LoadDataFromGroups(List<RuleGroupEntity> groups)
    {
        Data = groups.SelectMany(g => g.RuleConfigurations).Select(c => c.RuleDefinition).ToList();
    }
}

public T Get(Guid id)
{
    return Data.Where(x => x.Id == id).FirstOrDefault();
}

public T Get(Expression<Func<T, bool>> predicate)
{
    return Data.Where(predicate).FirstOrDefault();
}

public T Get(Func<T, bool> predicate)
{
    return Data.Where(predicate).FirstOrDefault();
}

public T Get(Expression<Func<T, bool>> predicate)
{
    return Data.AsQueryable().Where(predicate).FirstOrDefault();
}

// Old
//T Get(Expression<Func<T, bool>> predicate);

// new
T Get(Func<T, bool> predicate);

//public T Get(Expression<Func<T, bool>> predicate)
//{
//    var collection = GetCollection();
//    return collection.AsQueryable().Where(predicate).FirstOrDefault();
//}

public T Get(Func<T, bool> predicate)
{
    var collection = GetCollection().AsQueryable();
    return collection.Where(predicate).FirstOrDefault();
}

//public T Get(Expression<Func<T, bool>> predicate)
//{
//    throw new NotImplementedException();
//}

public T Get(Func<T, bool> predicate)
{
    return Data.AsQueryable().Where(predicate).FirstOrDefault();
}

required: using GRFExample;    

    var gevalues = Example.GetByType<GroupEntity>(Example.Test1().ToArray()).Cast<GroupEntity>();
            
    var cevalues = Example.GetByType<ConfigEntity>(Example.Test1().ToArray()).Cast<ConfigEntity>();
    
    var devalues = Example.GetByType<DefinitionEntity>(Example.Test1().ToArray()).Cast<DefinitionEntity>();

using System.Collections.Generic;

namespace GRFExample
{
    public static class Example
    {
        private static int id = 0;

        public static IEnumerable<GroupEntity> Test1()
        {
            for (var i = 0; i < 5; i++)
            {
                var ge = new GroupEntity();

                for (var j = 0; j < 4; j++)
                {
                    var ce = new ConfigEntity();
                    ce.dee = new DefinitionEntity(id++);
                    ge.cees.Add(ce);
                }

                yield return ge;
            }
        }

        public static IEnumerable<TheBase> GetByType<T>(params GroupEntity[] bees)
        {
            var pType = typeof(T).Name;

            foreach (var b in bees)
            {
                switch (pType)
                {
                    case "B":
                        yield return b;
                        break;

                    case "C":
                        foreach (var c in b.cees) yield return c;
                        break;

                    case "D":
                        foreach (var c in b.cees) yield return c.dee;
                        break;
                }
            }
        }
    }

    public class TheBase
    {
    }

    public class GroupEntity : TheBase
    {
        public List<ConfigEntity> cees = new List<ConfigEntity>();
    }

    public class ConfigEntity : TheBase
    {
        public DefinitionEntity dee;
    }

    public class DefinitionEntity : TheBase
    {
        public int id;

        public DefinitionEntity(int id)
        {
            this.id = id;
        }
    }
}