public FieldBuilder CreateField(SchemaBuilder schemaBuilder, PropertyInfo propertyInfo) { FieldBuilder fieldBuilder; // Check whether generic type is subentity or not var genericType = propertyInfo.PropertyType.GetGenericArguments()[0]; var iRevitEntity = genericType.GetInterface("IRevitEntity"); if (iRevitEntity != null) { fieldBuilder = schemaBuilder.AddArrayField(propertyInfo.Name, typeof(Entity)); AttributeExtractor <SchemaAttribute> schemaAttributeExtractor = new AttributeExtractor <SchemaAttribute>(); var subSchemaAttribute = schemaAttributeExtractor .GetAttribute(genericType); fieldBuilder .SetSubSchemaGUID(subSchemaAttribute.GUID); } else { fieldBuilder = schemaBuilder.AddArrayField(propertyInfo.Name, genericType); } return(fieldBuilder); }
private bool StoreElemDateTime(Element elem, string excelFileName, string excelWorksheetName, List <string> paramNames, List <string> massGroupingParams, FamilySymbol selectedSymbol, Level selectedLevel, string creationDateTime, string groupId) { string message = "start"; try { // Add schema data SchemaBuilder sBuilder = new SchemaBuilder(Properties.Settings.Default.SchemaIdElement); sBuilder.SetReadAccessLevel(AccessLevel.Public); sBuilder.SetWriteAccessLevel(AccessLevel.Public); sBuilder.SetVendorId("LMNA"); sBuilder.SetSchemaName("ProgramElem"); FieldBuilder fileFB = sBuilder.AddSimpleField("FileName", typeof(string)); fileFB.SetDocumentation("File path to the excel file."); message = "file name set"; FieldBuilder worksheetFB = sBuilder.AddSimpleField("Worksheet", typeof(string)); worksheetFB.SetDocumentation("Worksheet names for the imports"); message = "worksheet set"; FieldBuilder paramsFB = sBuilder.AddArrayField("ParameterNames", typeof(string)); paramsFB.SetDocumentation("Parameter names selected for this set of masses."); message = "parameternames set"; FieldBuilder groupingsFB = sBuilder.AddArrayField("GroupingParameters", typeof(string)); groupingsFB.SetDocumentation("Mass grouping parameters."); message = "grouping set"; FieldBuilder symbolFB = sBuilder.AddSimpleField("SymbolId", typeof(ElementId)); symbolFB.SetDocumentation("Symbol for mass family creation."); message = "symbols et"; FieldBuilder levelFB = sBuilder.AddSimpleField("LevelId", typeof(ElementId)); levelFB.SetDocumentation("Level for mass family creation."); message = "level set"; FieldBuilder dtFB = sBuilder.AddSimpleField("CreationTime", typeof(string)); dtFB.SetDocumentation("Creation time of this mass element per import."); message = "datetime set"; FieldBuilder gidFB = sBuilder.AddSimpleField("GroupId", typeof(string)); gidFB.SetDocumentation("GroupID based on GroupingParameters"); Schema schema = sBuilder.Finish(); Entity entity = new Entity(schema); entity.Set <string>("FileName", excelFileName); entity.Set <string>("Worksheet", excelWorksheetName); entity.Set <IList <string> >(schema.GetField("ParameterNames"), paramNames); entity.Set <IList <string> >(schema.GetField("GroupingParameters"), massGroupingParams); entity.Set <ElementId>("SymbolId", selectedSymbol.Id); entity.Set <ElementId>("LevelId", selectedLevel.Id); entity.Set <string>("CreationTime", creationDateTime); entity.Set <string>("GroupId", groupId); elem.SetEntity(entity); return(true); } catch (Exception ex) { TaskDialog.Show(message, ex.Message); return(false); } }
private static Schema CreateSchema() { Schema schema = null; try { var subBuilder = new SchemaBuilder(subSchemaId); subBuilder.SetSchemaName("MapItemInfoList"); subBuilder.AddSimpleField(s_SourceModelId, typeof(string)); subBuilder.AddSimpleField(s_RecipientModelId, typeof(string)); subBuilder.AddSimpleField(s_MapItemType, typeof(string)); subBuilder.AddSimpleField(s_SourceItemId, typeof(int)); subBuilder.AddSimpleField(s_RecipientItemId, typeof(int)); subBuilder.AddSimpleField(s_SourceItemName, typeof(string)); subBuilder.AddSimpleField(s_RecipientItemName, typeof(string)); subSchema = subBuilder.Finish(); var sBuilder = new SchemaBuilder(schemaId); sBuilder.SetSchemaName("ViewConfiguration"); sBuilder.AddSimpleField(s_WorksetVisibility, typeof(bool)); var fBuilder = sBuilder.AddArrayField(s_MapItems, typeof(Entity)); fBuilder.SetSubSchemaGUID(subSchemaId); schema = sBuilder.Finish(); } catch (Exception ex) { MessageBox.Show("Failed to create schema.\n" + ex.Message, "Create Schema", MessageBoxButton.OK, MessageBoxImage.Warning); } return(schema); }
internal static Schema GetSchema(Guid guid, string schemaName, IDictionary <string, ISet <string> > values) { // Ensure that the schema being generated is unique - // - otherwise, return the existing one. Schema schema = Schema.Lookup(guid); if (schema == null) { // 1. Create and name a new schema SchemaBuilder schemaBuilder = new SchemaBuilder(guid); schemaBuilder.SetSchemaName(schemaName); // 2. Set the read/write access schemaBuilder.SetReadAccessLevel(AccessLevel.Public); schemaBuilder.SetWriteAccessLevel(AccessLevel.Vendor); schemaBuilder.SetVendorId(VENDOR_ID); // 3. Define one or more fields of data foreach (string key in values.Keys) { if (schemaBuilder.AcceptableName(key)) { schemaBuilder.AddArrayField(key, typeof(string)); } else { System.Diagnostics.Trace.Write($"{key}"); } } schema = schemaBuilder.Finish(); } return(schema); }
/// <summary> /// Creates an array type field builder by field name. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="schemaBuilder"></param> /// <param name="fieldName"></param> /// <param name="unitType"></param> /// <param name="desc"></param> /// <returns></returns> public static FieldBuilder CreateArrayField <T>(this SchemaBuilder schemaBuilder, string fieldName, UnitType unitType, string desc = null) { if (schemaBuilder is null) { throw new ArgumentNullException(nameof(schemaBuilder)); } if (fieldName is null) { throw new ArgumentNullException(nameof(fieldName)); } if (desc is null) { throw new ArgumentNullException(nameof(desc)); } var result = schemaBuilder.AddArrayField(fieldName, typeof(T)); result.SetUnitType(unitType); result.SetDocumentation(desc); return(result); }
/// <summary> /// Creates an IEnumerable type field builder by field name. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="schemaBuilder"></param> /// <param name="fieldName"></param> /// <param name="unitType"></param> /// <param name="dcrp"></param> /// <returns></returns> public static void AddListField <T>(this SchemaBuilder schemaBuilder, string fieldName, UnitType unitType, string dcrp = null) { if (schemaBuilder is null) { throw new ArgumentNullException(nameof(schemaBuilder)); } if (fieldName is null) { throw new ArgumentNullException(nameof(fieldName)); } if (dcrp is null) { throw new ArgumentNullException(nameof(dcrp)); } if (!typeof(T).IsPrimitive) { throw new NotSupportedException(nameof(T)); } var result = schemaBuilder.AddArrayField(fieldName, typeof(IEnumerable <T>)); result.SetUnitType(unitType); result.SetDocumentation(dcrp); }
public override Schema GetOrCreateSchema() { SchemaBuilder sb = new SchemaBuilder(SchemaGuid); sb.SetSchemaName(SchemaName); sb.AddArrayField("someStringArray", typeof(string)); return sb.Finish(); }
public static Schema CreateSchema() { Schema schema = null; Schema subSchema = null; try { SchemaBuilder subSchemaBuilder = new SchemaBuilder(subSchemaId); subSchemaBuilder.SetSchemaName("ElementIds"); subSchemaBuilder.AddArrayField(s_ElementIds, typeof(ElementId)); subSchema = subSchemaBuilder.Finish(); SchemaBuilder schemaBuilder = new SchemaBuilder(schemaId); schemaBuilder.SetSchemaName("ColorEditorSetting"); schemaBuilder.AddSimpleField(s_BCFPath, typeof(string)); var mapField = schemaBuilder.AddMapField(s_ColoredElementIds, typeof(string), typeof(Entity)); mapField.SetSubSchemaGUID(subSchemaId); schema = schemaBuilder.Finish(); } catch (Exception ex) { MessageBox.Show("Failed to create schema for Color Scheme Editor.\n" + ex.Message, "Create Schema", MessageBoxButton.OK, MessageBoxImage.Warning); } return(schema); }
private static Schema CreateSchema() { Schema schema = null; try { SchemaBuilder subBuilder = new SchemaBuilder(subSchemaId); subBuilder.SetSchemaName("MassParameterMaps"); subBuilder.AddSimpleField(s_HostParameterName, typeof(string)); subBuilder.AddSimpleField(s_MassParameterName, typeof(string)); subSchema = subBuilder.Finish(); SchemaBuilder sBuilder = new SchemaBuilder(schemaId); sBuilder.SetSchemaName("MassConfiguration"); sBuilder.AddSimpleField(s_HostCategory, typeof(string)); sBuilder.AddSimpleField(s_MassCategory, typeof(string)); sBuilder.AddSimpleField(s_ParameterUpdateType, typeof(string)); sBuilder.AddSimpleField(s_SetDefaultHeight, typeof(bool)); FieldBuilder fBuilder = sBuilder.AddSimpleField(s_UserHeight, typeof(double)); fBuilder.SetUnitType(UnitType.UT_Length); fBuilder = sBuilder.AddArrayField(s_ParameterMaps, typeof(Entity)); fBuilder.SetSubSchemaGUID(subSchemaId); schema = sBuilder.Finish(); } catch (Exception ex) { MessageBox.Show("Failed to create schema.\n" + ex.Message, "Create Schema", MessageBoxButton.OK, MessageBoxImage.Warning); } return(schema); }
public override Schema GetOrCreateSchema() { SchemaBuilder sb = new SchemaBuilder(SchemaGuid); sb.SetSchemaName(SchemaName); sb.AddArrayField("someStringArray", typeof(string)); return(sb.Finish()); }
public Schema CreateSchema(Guid schemaGuid) { Schema schema = Schema.Lookup(schemaGuid); if (schema == null) { SchemaBuilder schemaBuilder = new SchemaBuilder(schemaGuid); schemaBuilder.SetReadAccessLevel(AccessLevel.Public); schemaBuilder.SetWriteAccessLevel(AccessLevel.Public); //schemaBuilder.SetWriteAccessLevel(AccessLevel.Vendor); //schemaBuilder.SetVendorId("CBIM"); FieldBuilder fieldBuilder = schemaBuilder.AddSimpleField("XYZ", typeof(XYZ)); fieldBuilder.SetUnitType(UnitType.UT_Length); fieldBuilder.SetDocumentation("I'm XYZ"); FieldBuilder fieldBuilder1 = schemaBuilder.AddSimpleField("Double", typeof(double)); fieldBuilder1.SetUnitType(UnitType.UT_Length); fieldBuilder1.SetDocumentation("I'm Double"); //Ilist<string> FieldBuilder fieldBuilder2 = schemaBuilder.AddArrayField("List", typeof(string)); //fieldBuilder2.SetUnitType(UnitType.UT_Length); fieldBuilder2.SetDocumentation("I'm Ilist<string>"); //IDictinary<string,int> FieldBuilder fieldBuilder3 = schemaBuilder.AddMapField("Dictionary", typeof(string), typeof(int)); //fieldBuilder3.SetUnitType(UnitType.UT_Length); fieldBuilder3.SetDocumentation("I'm IDictinary<string,int>"); //SubSchema //Guid guid = new Guid("f9b00633-6aa9-47a6-acea-7f74407b9ea5"); //Schema subSchema = Schema.Lookup(guid); //if (subSchema == null) //{ // SchemaBuilder subSchemaBuilder = new SchemaBuilder(guid); // subSchemaBuilder.SetReadAccessLevel(AccessLevel.Public); // subSchemaBuilder.SetWriteAccessLevel(AccessLevel.Public); // FieldBuilder sub = subSchemaBuilder.AddSimpleField("subInt", typeof(int)); // sub.SetDocumentation("I'm Int"); // subSchemaBuilder.SetSchemaName("SubSchema"); // subSchema = subSchemaBuilder.Finish(); //} //Entity subEntity = new Entity(subSchema); //subEntity.Set<int>(subSchema.GetField("subInt"), 11); //FieldBuilder fieldBuilder4 = schemaBuilder.AddSimpleField("SubEntity", typeof(Entity)); //fieldBuilder4.SetDocumentation("I'm SubSchema"); schemaBuilder.SetSchemaName("SchemaName"); schema = schemaBuilder.Finish(); } return(schema); }
private static Schema create_ElementListOfId() { SchemaBuilder sb = new SchemaBuilder(Guid_ElementListOfId); sb.SetSchemaName("ElementListOfId"); sb.SetReadAccessLevel(AccessLevel.Public); FieldBuilder fb1 = sb.AddArrayField("ElementList", typeof(string)); //element unique ids Schema sm = sb.Finish(); return(sm); }
/// <summary> /// Sets an entity. /// </summary> /// <param name="elm"></param> /// <param name="schemaName"></param> /// <param name="fields"></param> /// <returns></returns> public static void SetEntity(this Element elm, string schemaName, params FieldInfo[] fields) { if (elm is null) { throw new ArgumentNullException(nameof(elm)); } if (schemaName is null) { throw new ArgumentNullException(nameof(schemaName)); } if (fields is null) { throw new ArgumentNullException(nameof(fields)); } var guid = Guid.NewGuid(); var schemaBuilder = new SchemaBuilder(guid); schemaBuilder.SetReadAccessLevel(AccessLevel.Public); schemaBuilder.SetWriteAccessLevel(AccessLevel.Public); schemaBuilder.SetSchemaName(schemaName); foreach (var field in fields) { switch (field.FieldType) { case SchemaFieldType.Simple: schemaBuilder.AddSimpleField(field.FieldName, field.DataType); break; case SchemaFieldType.List: schemaBuilder.AddArrayField(field.FieldName, field.DataType); break; case SchemaFieldType.Dictionary: schemaBuilder.AddMapField(field.FieldName, field.KeyType, field.ValueType); break; default: throw new ArgumentOutOfRangeException(); } } elm.SetEntity(new Entity(schemaBuilder.Finish())); }
private static Guid FindOrCreateSchema(Document doc) { // find schema RvtSchema = Schema.Lookup(RvtGuid); try { // Find or read subschemas needed Guid provGuid = Provider.FindOrCreateSchema(doc); Guid servGuid = Service.FindOrCreateSchema(doc); // create schema if not found if (RvtSchema == null) { // Start transaction Transaction createSchema = new Transaction(doc, "Create Bimbot Schema"); createSchema.Start(); // Build schema SchemaBuilder schemaBldr = new SchemaBuilder(RvtGuid); // Set read and write access attributes and a name schemaBldr.SetReadAccessLevel(AccessLevel.Application); schemaBldr.SetWriteAccessLevel(AccessLevel.Application); schemaBldr.SetApplicationGUID(RevitBimbot.ApplicationGuid); schemaBldr.SetVendorId(RevitBimbot.VendorId); schemaBldr.SetSchemaName("BimBotDocument"); // create a field to store services FieldBuilder fieldBldr = schemaBldr.AddMapField(ProvidersField, typeof(string), typeof(Entity)); fieldBldr.SetDocumentation("Dictionary of providers by url of service(s) in this project."); fieldBldr.SetSubSchemaGUID(provGuid); fieldBldr = schemaBldr.AddArrayField(ServicesField, typeof(Entity)); fieldBldr.SetDocumentation("List of services assigned to this project."); fieldBldr.SetSubSchemaGUID(servGuid); RvtSchema = schemaBldr.Finish(); // register the Schema object createSchema.Commit(); } else { RvtSchema = Schema.Lookup(RvtGuid); } } catch (Exception e) { Console.WriteLine(e); } return(RvtGuid); }
/// 添加字段 /// <summary> /// 构造函数,创建schema 表 /// </summary> private SchemaOpr() { //创建dictionary方式的schema System.Guid guid = GetCurGuid(); SchemaBuilder builder = new SchemaBuilder(guid); // Set name to this schema builder builder.SetSchemaName("PmSchemaComn"); builder.SetDocumentation("品茗通用的数据扩展结构"); // Set read and write access levels builder.SetReadAccessLevel(AccessLevel.Public); builder.SetWriteAccessLevel(AccessLevel.Public); // 版本号,升级用 builder.AddSimpleField("versionNum", typeof(short)); // string元素 builder.AddMapField("parms_str", typeof(string), typeof(string)); // double元素 FieldBuilder fb = builder.AddMapField("parms_double", typeof(string), typeof(double)); fb.SetUnitType(UnitType.UT_Length); // element元素 builder.AddMapField("parms_element", typeof(string), typeof(ElementId)); // 表格元素 builder.AddArrayField("tables_name", typeof(string)); //段名称 builder.AddArrayField("tables_postion", typeof(int)); //段的二进制位置 builder.AddArrayField("tables_content", typeof(byte)); //段的内容 // m_schema = builder.Finish(); }
/// <summary> /// Creates an array type field builder by field name. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="schemaBuilder"></param> /// <param name="fieldName"></param> /// <param name="unitType"></param> /// <param name="decription"></param> /// <returns></returns> public static FieldBuilder CreateArrayField <T>(this SchemaBuilder schemaBuilder, string fieldName, UnitType unitType, string decription = null) { var result = schemaBuilder.AddArrayField(fieldName, typeof(T)); result.SetUnitType(unitType); if (decription == null) { decription = fieldName; } result.SetDocumentation(decription); return(result); }
public ExtensibleStorage(string guid, string SchemaName, string FieldName, Type ValueType, string Fielddocumentation) { this.Schema_Name = SchemaName; this.Field_Name = FieldName; this.Value_Type = ValueType; this.schemaBuilder = new SchemaBuilder(new Guid(guid)); schemaBuilder.SetReadAccessLevel(AccessLevel.Public); schemaBuilder.SetWriteAccessLevel(AccessLevel.Public); // create a field to store a string map this.FieldDocumentation = Fielddocumentation; this.fieldBuilder = schemaBuilder.AddArrayField(Field_Name, ValueType); fieldBuilder.SetDocumentation(FieldDocumentation); schemaBuilder.SetSchemaName(Schema_Name); schema = schemaBuilder.Finish(); }
public static Schema GetSchema( ) { var schema = Schema.Lookup(schemaGuid); if (schema != null) { return(schema); } var builder = new SchemaBuilder(schemaGuid); builder.SetSchemaName("SpeckleLocalStateStorage"); builder.AddArrayField("streams", typeof(string)); return(builder.Finish()); }
/// <summary> /// Retrieve an existing EstoreFile schema or /// create a new one if it does not exist yet. /// </summary> /// <returns>EstoreFile schema</returns> static Schema GetSchema() { Schema schema = Schema.Lookup(CmdStore._schema_guid); if (null == schema) { SchemaBuilder schemaBuilder = new SchemaBuilder(_schema_guid); schemaBuilder.SetSchemaName("EstoreFile"); // Allow anyone to read and write the object schemaBuilder.SetReadAccessLevel( AccessLevel.Public); schemaBuilder.SetWriteAccessLevel( AccessLevel.Public); // Create fields FieldBuilder fieldBuilder = schemaBuilder .AddSimpleField("Filename", typeof(string)); fieldBuilder.SetDocumentation("File name"); fieldBuilder = schemaBuilder.AddSimpleField( "Folder", typeof(string)); fieldBuilder.SetDocumentation("Original file folder path"); fieldBuilder = schemaBuilder.AddArrayField( "Data", typeof(byte)); fieldBuilder.SetDocumentation("Stored file data"); // Register the schema schema = schemaBuilder.Finish(); } return(schema); }
private static readonly Guid RvtGuid = new Guid("a54b4c89-0ee7-4fae-8fbd-b13b04f01a01"); //b13b04 = bimbot, f01 = service data, a01 = version 0.1 public static Guid FindOrCreateSchema(Document doc) { // find schema RvtSchema = Schema.Lookup(RvtGuid); try { // Find or read subschemas needed Guid provGuid = Provider.FindOrCreateSchema(doc); // create schema if not found if (RvtSchema == null) { // Start transaction Transaction createSchema = new Transaction(doc, "Create Service Schema"); createSchema.Start(); // Build schema SchemaBuilder serviceBldr = new SchemaBuilder(RvtGuid); // Set read and write access attributes and a name serviceBldr.SetReadAccessLevel(AccessLevel.Application); serviceBldr.SetWriteAccessLevel(AccessLevel.Application); serviceBldr.SetApplicationGUID(RevitBimbot.ApplicationGuid); serviceBldr.SetVendorId(RevitBimbot.VendorId); serviceBldr.SetSchemaName("BimBotService"); // create fields for relevant attributes of services FieldBuilder fieldBldr = serviceBldr.AddSimpleField(NameField, typeof(string)); fieldBldr.SetDocumentation("Name of the service."); fieldBldr = serviceBldr.AddSimpleField(DescriptionField, typeof(string)); fieldBldr.SetDocumentation("Decription of the service."); fieldBldr = serviceBldr.AddArrayField(InputsField, typeof(string)); fieldBldr.SetDocumentation("List of input types of the service."); fieldBldr = serviceBldr.AddArrayField(OutputsField, typeof(string)); fieldBldr.SetDocumentation("List of output types the service."); fieldBldr = serviceBldr.AddSimpleField(UrlField, typeof(string)); fieldBldr.SetDocumentation("Url of the service."); fieldBldr = serviceBldr.AddArrayField(TriggersField, typeof(string)); fieldBldr.SetDocumentation("List of triggers that activate the service."); fieldBldr = serviceBldr.AddSimpleField(ProviderField, typeof(string)); fieldBldr.SetDocumentation("Name of the Provider of the service."); fieldBldr = serviceBldr.AddSimpleField(AuthorizationField, typeof(string)); fieldBldr.SetDocumentation("Code used for authorizing the service."); fieldBldr = serviceBldr.AddSimpleField(IfcConfigurationField, typeof(string)); fieldBldr.SetDocumentation("IFC export configuration used when running the service."); fieldBldr = serviceBldr.AddSimpleField(LastRunField, typeof(string)); fieldBldr.SetDocumentation("Last date the service was executed."); fieldBldr = serviceBldr.AddSimpleField(ResultTypeField, typeof(string)); fieldBldr.SetDocumentation("Last result type delivered by the service."); fieldBldr = serviceBldr.AddSimpleField(ResultDataField, typeof(string)); fieldBldr.SetDocumentation("Last results delivered by the service."); RvtSchema = serviceBldr.Finish(); // register the subSchema object createSchema.Commit(); } else { RvtSchema = Schema.Lookup(RvtGuid); } } catch (Exception e) { Console.WriteLine(e); } return(RvtGuid); }
/// <summary> /// Create a new Autodesk.Revit.DB.ExtensibleStorage.SchemaBuilder and Schema from /// the data in the SchemaWrapper. /// </summary> public void FinishSchema() { //Create the Autodesk.Revit.DB.ExtensibleStorage.SchemaBuilder that actually builds the schema m_SchemaBuilder = new SchemaBuilder(new Guid(m_SchemaDataWrapper.SchemaId)); //We will add a new field to our schema from each FieldData object in our SchemaWrapper foreach (FieldData currentFieldData in m_SchemaDataWrapper.DataList) { //If the current field's type is a supported system type (int, string, etc...), //we can instantiate it with Type.GetType(). If the current field's type is a supported Revit API type //(XYZ, elementID, etc...), we need to call GetType from the RevitAPI.dll assembly object. Type fieldType = null; try { fieldType = Type.GetType(currentFieldData.Type, true, true); } catch (Exception ex) //Get the type from the Revit API assembly if it is not a system type. { Debug.WriteLine(ex.ToString()); try { //Get the field from the Revit API assembly. fieldType = m_Assembly.GetType(currentFieldData.Type); } catch (Exception exx) { Debug.WriteLine("Error getting type: " + exx.ToString()); throw; } } //Now that we have the data type of field we need to add, we need to call either //SchemaBuilder.AddSimpleField, AddArrayField, or AddMapField. FieldBuilder currentFieldBuilder = null; Guid subSchemaId = Guid.Empty; Type[] genericParams = null; if (currentFieldData.SubSchema != null) { subSchemaId = new Guid(currentFieldData.SubSchema.Data.SchemaId); } //If our data type is a generic, it is an IList<> or an IDictionary<>, so it's an array or map type if (fieldType.IsGenericType) { Type tGeneric = fieldType.GetGenericTypeDefinition(); //tGeneric will be either an IList<> or an IDictionary<>. //Create an IList<> or an IDictionary<> to compare against tGeneric. Type iDictionaryType = typeof(IDictionary <int, int>).GetGenericTypeDefinition(); Type iListType = typeof(IList <int>).GetGenericTypeDefinition(); genericParams = fieldType.GetGenericArguments(); //Get the actual data type(s) stored in the field's IList<> or IDictionary<> if (tGeneric == iDictionaryType) { //Pass the key and value type of our dictionary type to AddMapField. currentFieldBuilder = m_SchemaBuilder.AddMapField(currentFieldData.Name, genericParams[0], genericParams[1]); } else if (tGeneric == iListType) { //Pass the value type of our list type to AddArrayField. currentFieldBuilder = m_SchemaBuilder.AddArrayField(currentFieldData.Name, genericParams[0]); } else { throw new Exception("Generic type is neither IList<> nor IDictionary<>, cannot process."); } } else { //The simpler case -- just add field using a name and a System.Type. currentFieldBuilder = m_SchemaBuilder.AddSimpleField(currentFieldData.Name, fieldType); } if ( //if we're dealing with an Entity as a simple field, map field, or list field and need to do recursion... (fieldType == (typeof(Entity))) || (fieldType.IsGenericType && ((genericParams[0] == (typeof(Entity))) || ((genericParams.Length > 1) && (genericParams[1] == typeof(Entity))))) ) { currentFieldBuilder.SetSubSchemaGUID(subSchemaId); //Set the SubSchemaID if our field currentFieldData.SubSchema.FinishSchema(); //Recursively create the schema for the subSchema. } if (!currentFieldData.Spec.Empty()) { currentFieldBuilder.SetSpec(currentFieldData.Spec); } } //Set all the top level data in the schema we are generating. m_SchemaBuilder.SetReadAccessLevel(this.Data.ReadAccess); m_SchemaBuilder.SetWriteAccessLevel(this.Data.WriteAccess); m_SchemaBuilder.SetVendorId(this.Data.VendorId); m_SchemaBuilder.SetApplicationGUID(new Guid(this.Data.ApplicationId)); m_SchemaBuilder.SetDocumentation(this.Data.Documentation); m_SchemaBuilder.SetSchemaName(this.Data.Name); //Actually finish creating the Autodesk.Revit.DB.ExtensibleStorage.Schema. m_Schema = m_SchemaBuilder.Finish(); }