Пример переопределения

using System;
using System.Collections.Generic;
using System.Linq;
using EleWise.ELMA.Actions;
using EleWise.ELMA.ComponentModel;
using EleWise.ELMA.Extensions;
using EleWise.ELMA.Model.Mappings;
using EleWise.ELMA.Model.Metadata;
using EleWise.ELMA.Model.Services;
using EleWise.ELMA.Model.Types;
using EleWise.ELMA.Model.Types.Settings;
using EleWise.ELMA.Helpers;
using EleWise.ELMA.Services.Public;
using Yambr.ELMA.MindMap.Models;

namespace Yambr.ELMA.MindMap.Services.Impl
{
    [Service]
    public class MindMupMetadataService : IMindMupMetadataService
    {
        public static readonly Dictionary<Guid,int> MetadataMap = new Dictionary<Guid,int>();

        private readonly IMetadataRuntimeService _metadataRuntimeService;
        private readonly PublicMetadataService _publicMetadataService;
        public MindMupMetadataService(IMetadataRuntimeService metadataRuntimeService, PublicMetadataService publicMetadataService)
        {
            _metadataRuntimeService = metadataRuntimeService;
            _publicMetadataService = publicMetadataService;
        }
        public MindMup FullMindMup()
        {
            return null;
        }

        public MindMup MindMup(ICollection<Guid> typeGuids)
        {
            var mindmup = new MindMup();
            var mupName = "394c.0b22360a-f10d.56446fa45";
            var links = new List<LinkElement>();
            var types = Types().Where(c => typeGuids.Contains(c.Uid)).ToArray();
            for (var i = 0; i < types.Length; i++)
            {
                const int size = 10;
                var y = i / size;
                var x = i < 10 ? i : (i % size);
                var metadata = types[i].GetMetadata();
                var mindMupIdea = new MindMupIdea()
                {
                    Attr = new IdeaAttrs(x * 100, y * 100)
                };

                if (metadata is EntityMetadata)
                {
                    var entityMetadata = (EntityMetadata) metadata;
                    mindMupIdea.Title = entityMetadata.DisplayName;
                    mindMupIdea.Id = Id(entityMetadata, mupName);
                    mindMupIdea.Ideas = GetProperties(mupName, entityMetadata, links, typeGuids);

                    if (entityMetadata.BaseClassUid != Guid.Empty)
                    {
                        AddBaseMetadata(typeGuids, entityMetadata, mupName, mindMupIdea, links);
                    }
                    mindmup.Ideas.Add(Id(entityMetadata), mindMupIdea);

                }
                else if(metadata is EnumMetadata)
                {
                    var enumMetadata = (EnumMetadata)metadata;
                    mindMupIdea.Title = enumMetadata.DisplayName;
                    mindMupIdea.Id = Id(enumMetadata, mupName);
                    mindMupIdea.Ideas = GetValues(mupName, enumMetadata);
                    mindmup.Ideas.Add(IdByUid(metadata), mindMupIdea);
                }
            }


            mindmup.Links = links.ToArray();
            return mindmup;
        }

        private void AddBaseMetadata(ICollection<Guid> typeGuids, EntityMetadata entityMetadata, string mupName,
            MindMupIdea mindMupIdea, List<LinkElement> links)
        {
            if(!typeGuids.Contains(entityMetadata.BaseClassUid))
                typeGuids.Add(entityMetadata.BaseClassUid);

            var parentMetsdata = _publicMetadataService.LoadMetadata(entityMetadata.BaseClassUid) as EntityMetadata;
            if (parentMetsdata == null) return;
            var parentId = $"{entityMetadata.Uid}{parentMetsdata.Uid}".GetDeterministicGuid();
            var mupIdea = new MindMupIdea()
            {
                Id = Id(parentId, mupName),
                Title = $"#BASE : {parentMetsdata.DisplayName}"
            };
            mindMupIdea.Ideas.Add(Id(parentId), mupIdea);
            var linkElement = new LinkElement()
            {
                IdeaIdFrom = Id(parentId, mupName),
                IdeaIdTo = Id(parentMetsdata.Uid, mupName),
            };
            linkElement.Attr.Style.LineStyle = "dashed";
            links.Add(linkElement);
        }
        private static string Id(EntityMetadata metadata, string mupName)
        {
            return $"{Id(metadata)}.{mupName}";
        }

        private static string Id(EntityMetadata metadata)
        {
            return Id(metadata.Name.GetDeterministicGuid());
        }
        private static string Id(EnumMetadata metadata, string mupName)
        {
            return $"{IdByUid(metadata)}.{mupName}";
        }
        private static string Id(EnumValueMetadata metadata, string mupName)
        {
            return $"{IdByUid(metadata)}.{mupName}";
        }

        private static string Id(IPropertyMetadata metadata, string mupName)
        {
            return $"{IdByUid(metadata)}.{mupName}";
        }

        private static string IdByUid(IMetadata metadata)
        {
            var metadataUid = metadata.Uid;
            return Id(metadataUid);
        }
        private static string Id(Guid metadataUid, string mupName)
        {
            return $"{Id(metadataUid)}.{mupName}";
        }
        private static string Id(Guid metadataUid)
        {
            if (!MetadataMap.ContainsKey(metadataUid))
            {
                var i = MetadataMap.Any() ? MetadataMap.Max(c => c.Value) + 1 : 1;
                MetadataMap.Add(metadataUid, i);
            }

            var metadata1 = MetadataMap[metadataUid];
            return metadata1.ToString();
        }

        private Dictionary<string, MindMupIdea> GetValues(string mupName, EnumMetadata publicMetadataInfo)
        {
            var metaProps = publicMetadataInfo.Values;

            var props =
                metaProps
                    .ToDictionary(IdByUid,
                        propertyMetadata =>
                        {
                            var mindMupIdea = new MindMupIdea()
                            {
                                Id = Id(propertyMetadata, mupName),
                                Title = propertyMetadata.Name,
                                Ideas = Ideas(mupName, propertyMetadata)
                            };
                            return mindMupIdea;
                        });
            return props;
        }



        private static Dictionary<string, MindMupIdea> Ideas(string mupName, EnumValueMetadata propertyMetadata)
        {
            var propertyMetadataUid = $"{propertyMetadata.Uid}".GetDeterministicGuid();
            return new Dictionary<string, MindMupIdea>() {
                {
                    Id(propertyMetadataUid),
                    new MindMupIdea()
                    {
                        Id = Id(propertyMetadataUid, mupName),
                        Title = $"{propertyMetadata.DisplayName} ({propertyMetadata.IntValue?.ToString() ?? propertyMetadata.UidStr})"
                    }
                }
            };
        }

        private Dictionary<string, MindMupIdea> GetProperties(string mupName, EntityMetadata entityMetadata, ICollection<LinkElement> links, ICollection<Guid> typeGuids)
        {
            var metaProps = entityMetadata.GetPropertiesAndTableParts().ToList();

            var parentMeta = _publicMetadataService.LoadMetadata(entityMetadata.BaseClassUid) as EntityMetadata;

            if (parentMeta != null)
            {
                metaProps.RemoveAll(c => parentMeta.Properties.Any(p => p.Uid == c.Uid));
            }

            var props =
                metaProps
                    .ToDictionary(IdByUid,
                        propertyMetadata =>
                        {
                            var mindMupIdea = new MindMupIdea()
                            {
                                Id = Id(propertyMetadata, mupName),
                                Title = propertyMetadata.Name,
                                Ideas = MindMupIdeas(mupName, propertyMetadata)
                            };
                            return mindMupIdea;
                        });

            AddLinks(mupName, links, typeGuids, metaProps);
            return props;

        }

        private static Dictionary<string, MindMupIdea> MindMupIdeas(string mupName, IPropertyMetadata propertyMetadata)
        {
            var metadataUid = $"{propertyMetadata.Uid}".GetDeterministicGuid();
            return new Dictionary<string, MindMupIdea>() {
                {
                    Id(metadataUid),
                    new MindMupIdea()
                    {
                        Id = Id(metadataUid, mupName),
                        Title = propertyMetadata.DisplayName
                    }
                }
            };
        }

        private void AddLinks(string mupName, ICollection<LinkElement> links, ICollection<Guid> typeGuids, List<IPropertyMetadata> metaProps)
        {
            foreach (var prop in metaProps)
            {
                if (prop.SubTypeUid != Guid.Empty)
                {
                    var metadata = _publicMetadataService.LoadMetadata(prop.SubTypeUid);
                    if (metadata is EntityMetadata)
                    {
                        var propMeta = (EntityMetadata)metadata;
                        if (typeGuids.Contains(propMeta.ImplementationUid))
                        {
                            var linkElement = new LinkElement()
                            {
                                IdeaIdFrom = Id(prop, mupName),
                                IdeaIdTo = Id(propMeta, mupName),
                            };

                            //TODO переделать на serializableTypeDescriptor
                            var entitySettings = prop.Settings as EntitySettings;
                            if (entitySettings != null)
                            {
                                linkElement.Attr.Style.Label = $"({EnumHelper.GetDisplayName(entitySettings.RelationType)})";
                            }
                            links.Add(linkElement);
                        }
                    }

                    if (metadata is EnumMetadata)
                    {
                        var propMeta = (EnumMetadata)metadata;
                        links.Add(new LinkElement()
                        {
                            IdeaIdFrom = Id(prop, mupName),
                            IdeaIdTo = Id(propMeta, mupName),
                        });
                    }
                }
            }
        }

        public IPublicMetadataInfo[] Types()
        {
            var publicMetadataInfos = GetAllMetadataInfo<EntityMetadata>(FilterEntityMetadata).ToList();
            publicMetadataInfos.AddRange(GetAllMetadataInfo<EnumMetadata>());
            return publicMetadataInfos.ToArray();
        }

        private static bool FilterEntityMetadata(EntityMetadata m)
        {
            if (m.IdTypeUid != Int64Descriptor.UID && m.IdTypeUid != Int32Descriptor.UID &&
                m.IdTypeUid != Int16Descriptor.UID) return false;
            if (m.Type != 0)
            {
                return m.Type == EntityMetadataType.InterfaceImplementation;
            }
            return true;
        }

        private IPublicMetadataInfo[] GetAllMetadataInfo<T>(Func<T, bool> func = null) where T : class, IMetadata
        {
            return _publicMetadataService.GetMetadataInfoList().Where(delegate (IPublicMetadataInfo i)
            {
                var val = i.GetMetadata() as T;
                if (val != null)
                {
                    return func == null || func(val);
                }
                return false;
            }).ToArray();
        }
    }
}