Exemple #1
0
        T IDebuggable.GetDebugInfo <T>(int parentDepth, int childDepth)
        {
            var debug = new DebugDataScopeRules
            {
                Instance = this,
                Name     = "data scope rules for " + ElementName,
            };

            lock (_lock)
            {
                debug.Scopes = DataScopes
                               .Select(s => new DebugDataScope {
                    DataType = s.DataType, ScopeName = s.ScopeName
                })
                               .ToList();

                debug.DataSupplies = SuppliedDependencies
                                     .Select(suppliedDependency =>
                                             new DebugSuppliedDependency
                {
                    Supplier = suppliedDependency.Item1.GetDebugInfo <DebugDataSupplier>(),

                    DataTypeSupplied = suppliedDependency.Item2 == null
                                ? null
                                : new DebugDataScope
                    {
                        DataType  = suppliedDependency.Item2.DataType,
                        ScopeName = suppliedDependency.Item2.ScopeName
                    }
                })
                                     .ToList();
            }

            return(debug as T);
        }
Exemple #2
0
        public void AddScope(Type type, string scopeName)
        {
            lock (_lock)
            {
                if (DataScopes.Any(s =>
                                   (s.DataType == type) &&
                                   (string.Equals(s.ScopeName, scopeName, StringComparison.InvariantCultureIgnoreCase))))
                {
                    return;
                }

                var dataScope = _dataScopeFactory.Create(type, scopeName);
                DataScopes.Add(dataScope);
            }
        }
        /// <summary>
        /// Serialize the data type description to XML
        /// </summary>
        /// <returns>Serialized data type descriptor</returns>
        public XElement ToXml()
        {
            var element = new XElement("DataTypeDescriptor",
                                       new XAttribute("dataTypeId", this.DataTypeId),
                                       new XAttribute("name", this.Name),
                                       new XAttribute("namespace", this.Namespace),
                                       this.Title != null ? new XAttribute("title", this.Title) : null,
                                       new XAttribute("isCodeGenerated", this.IsCodeGenerated),
                                       new XAttribute("cachable", this.Cachable),
                                       new XAttribute("searchable", this.Searchable),
                                       this.LabelFieldName != null ? new XAttribute("labelFieldName", this.LabelFieldName) : null,
                                       !string.IsNullOrEmpty(this.InternalUrlPrefix) ? new XAttribute("internalUrlPrefix", this.InternalUrlPrefix) : null,
                                       this.TypeManagerTypeName != null ? new XAttribute("typeManagerTypeName", this.TypeManagerTypeName) : null,
                                       !string.IsNullOrEmpty(this.BuildNewHandlerTypeName) ? new XAttribute("buildNewHandlerTypeName", this.BuildNewHandlerTypeName) : null);


            element.Add(new[]
            {
                new XElement("DataAssociations",
                             DataAssociations.Select(da => da.ToXml())),
                new XElement("DataScopes",
                             DataScopes.Select(dsi => new XElement("DataScopeIdentifier", new XAttribute("name", dsi)))),
                new XElement("KeyPropertyNames",
                             KeyPropertyNames.Select(name => new XElement("KeyPropertyName", new XAttribute("name", name)))),
                VersionKeyPropertyNames.Any()
                    ? new XElement("VersionKeyPropertyNames",
                                   VersionKeyPropertyNames.Select(name => new XElement("VersionKeyPropertyName", new XAttribute("name", name))))
                    : null,
                new XElement("SuperInterfaces",
                             SuperInterfaces.Select(su => new XElement("SuperInterface", new XAttribute("type", TypeManager.SerializeType(su))))),
                new XElement("Fields", Fields.Select(f => f.ToXml()))
            });

            if (Indexes.Any())
            {
                element.Add(new XElement("Indexes", Indexes.Select(i => i.ToXml())));
            }

            return(element);
        }