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;
        }
    }
}

bool Draw_Mirror_Image = checkBox_mirror_image.Checked;

            bool Flip_horz_or_vert = radioButton_mirr_img_FV.Checked;
            //Flip_horz_or_vert     =   false for flip horizontal 
            //                  and =   true for flip vertical


            StringFormat stringFormat = new StringFormat();
            stringFormat.Alignment = StringAlignment.Center;
            stringFormat.LineAlignment = StringAlignment.Center;

            stringFormat.FormatFlags = StringFormatFlags.LineLimit;
            stringFormat.Trimming = StringTrimming.Word;


            RectangleF rect2 = panel2.ClientRectangle;
            float image_draw_wd = 200;
            float image_draw_ht = 100;

            int X = 0;
            int Y = 0;

            Brush myBrush = new SolidBrush(Color.FromArgb(128, Color.Blue));
            
            int ROW=3;
            int COL=3;
            Pen pen = new Pen(Color.Red, 4);

            float Zoom_Value = 100;

            float X_SF = 1;
            float Y_SF = 1;

            string draw_text = "35";

            Font draw_text_Font = new Font("Microsoft Sans Serif", 18, FontStyle.Bold);

            for (int r = 1; r <= ROW; r++)
            {
                X = 0;

                for (int cl = 1; cl <= COL; cl++)
                {

                    draw_text = "ROW : " + r.ToString() + "\nCOL : " + cl.ToString();

                    Rectangle dr_rect = new Rectangle(new Point(X, Y), new Size((int)image_draw_wd, ((int)image_draw_ht)));


                    if (Draw_Mirror_Image)
                    {
                        if (Flip_horz_or_vert == false)
                        {
                           //flip horz

                            pe.ScaleTransform(-X_SF, Y_SF);
                            //pe.TranslateTransform(-((X + image_draw_wd) * (float)(Zoom_Value / 100f)), 0);
                            pe.TranslateTransform(-((image_draw_wd) * (float)(Zoom_Value / 100f)), 0);
                        }
                        else
                        { 
                            //flip vert

                            pe.ScaleTransform(X_SF, -Y_SF);
                            //pe.TranslateTransform(0, -((Y + image_draw_ht) * (float)(Zoom_Value / 100f)));
                            pe.TranslateTransform(0, -((image_draw_ht) * (float)(Zoom_Value / 100f)));
                        }
                    }

                    pe.DrawString(draw_text, draw_text_Font, myBrush, dr_rect, stringFormat);

                    pe.DrawRectangle(pen, dr_rect);

                    X = X + (int)image_draw_wd;
                }


                Y = Y + (int)image_draw_ht;
                
            }