private static void BuildResultListNoResult(ICSharpUsingCollection usingCollection, IList <ICSharpParameter> resultList, ref string parameterListText, ref string parameterNameListText, out string resultTypeText) { resultTypeText = "void"; foreach (ICSharpParameter Result in resultList) { ICSharpScopeAttributeFeature ResultAttribute = Result.Feature; ICSharpType ParameterType = ResultAttribute.Type; CSharpTypeFormats ParameterFormat = ParameterType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string TypeString = ParameterType.Type2CSharpString(usingCollection, ParameterFormat, CSharpNamespaceFormats.None); string AttributeString = CSharpNames.ToCSharpIdentifier(Result.Name); if (parameterListText.Length > 0) { parameterListText += ", "; } if (parameterNameListText.Length > 0) { parameterNameListText += ", "; } parameterListText += $"out {TypeString} {AttributeString}"; parameterNameListText += $"out {AttributeString}"; } }
/// <summary> /// Builds a list of parameters, with and without their type. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="parameterList">The list of parameters.</param> /// <param name="parameterListText">The list of parameters with type upon return.</param> /// <param name="parameterNameListText">The list of parameters without type upon return.</param> public static void BuildParameterList(ICSharpUsingCollection usingCollection, IList <ICSharpParameter> parameterList, out string parameterListText, out string parameterNameListText) { parameterListText = string.Empty; parameterNameListText = string.Empty; foreach (ICSharpParameter Parameter in parameterList) { if (parameterListText.Length > 0) { parameterListText += ", "; } if (parameterNameListText.Length > 0) { parameterNameListText += ", "; } string ParameterName = Parameter.Name; ICSharpType ParameterType = Parameter.Feature.Type; CSharpTypeFormats ParameterFormat = ParameterType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string ParameterText = ParameterType.Type2CSharpString(usingCollection, ParameterFormat, CSharpNamespaceFormats.None); string ParameterNameText = CSharpNames.ToCSharpIdentifier(ParameterName); parameterListText += $"{ParameterText} {ParameterNameText}"; parameterNameListText += ParameterNameText; } }
/// <summary> /// Get the name of a type. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="cSharpTypeFormat">The type format.</param> /// <param name="cSharpNamespaceFormat">The namespace format.</param> public override string Type2CSharpString(ICSharpUsingCollection usingCollection, CSharpTypeFormats cSharpTypeFormat, CSharpNamespaceFormats cSharpNamespaceFormat) { SetUsedInCode(); string Result; if (OriginatingTypedef != null) { // TODO string DelegateName = CSharpNames.ToCSharpIdentifier(OriginatingTypedef.Name); Result = PropertyType2CSharpString(DelegateName); } else { string BaseTypeText = BaseType.Type2CSharpString(usingCollection, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None); string EntityTypeText = EntityType.Type2CSharpString(usingCollection, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None); Result = $"Func<{BaseTypeText}, {EntityTypeText}>"; usingCollection.AddUsing(nameof(System)); } return(Result); }
/// <summary> /// Builds a list of parameters, with and without their type. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="parameterList">The list of parameters.</param> /// <param name="resultList">The list of results.</param> /// <param name="featureTextType">The write mode.</param> /// <param name="parameterListText">The list of parameters with type upon return.</param> /// <param name="parameterNameListText">The list of parameters without type upon return.</param> /// <param name="resultTypeText">The type text upon return.</param> public static void BuildParameterList(ICSharpUsingCollection usingCollection, IList <ICSharpParameter> parameterList, IList <ICSharpParameter> resultList, CSharpFeatureTextTypes featureTextType, out string parameterListText, out string parameterNameListText, out string resultTypeText) { parameterListText = string.Empty; parameterNameListText = string.Empty; foreach (ICSharpParameter Parameter in parameterList) { if (parameterListText.Length > 0) { parameterListText += ", "; } if (parameterNameListText.Length > 0) { parameterNameListText += ", "; } string ParameterName = Parameter.Name; ICSharpType ParameterType = Parameter.Feature.Type; CSharpTypeFormats ParameterFormat = ParameterType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string ParameterText = ParameterType.Type2CSharpString(usingCollection, ParameterFormat, CSharpNamespaceFormats.None); string ParameterNameText = CSharpNames.ToCSharpIdentifier(ParameterName); parameterListText += $"{ParameterText} {ParameterNameText}"; parameterNameListText += ParameterNameText; } if (resultList.Count == 1) { BuildResultListSingle(usingCollection, resultList, out resultTypeText); } else { int ResultIndex = -1; for (int i = 0; i < resultList.Count; i++) { ICSharpParameter Result = resultList[i]; if (Result.Name == nameof(BaseNode.Keyword.Result)) { ResultIndex = i; break; } } if (ResultIndex < 0) { BuildResultListNoResult(usingCollection, resultList, ref parameterListText, ref parameterNameListText, out resultTypeText); } else { BuildResultListWithResult(usingCollection, resultList, ResultIndex, ref parameterListText, ref parameterNameListText, out resultTypeText); } } }
private static void BuildResultListSingle(ICSharpUsingCollection usingCollection, IList <ICSharpParameter> resultList, out string resultTypeText) { Debug.Assert(resultList.Count == 1); ICSharpParameter Result = resultList[0]; ICSharpScopeAttributeFeature ResultAttribute = Result.Feature; /*if (FeatureTextType == FeatureTextTypes.Interface) * ResultType = CSharpTypes.Type2CSharpString(ResultAttribute.ResolvedFeatureType.Item, Context, CSharpTypeFormats.AsInterface); * else * ResultType = CSharpTypes.Type2CSharpString(ResultAttribute.ResolvedFeatureType.Item, Context, CSharpTypeFormats.None);*/ resultTypeText = ResultAttribute.Type.Type2CSharpString(usingCollection, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None); }
/// <summary> /// Gets the singleton text corresponding to this type, if any. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="cSharpTypeFormat">The type format.</param> /// <param name="cSharpNamespaceFormat">The namespace format.</param> /// <param name="text">The singleton text upon return, if successful.</param> public override bool GetSingletonString(ICSharpUsingCollection usingCollection, CSharpTypeFormats cSharpTypeFormat, CSharpNamespaceFormats cSharpNamespaceFormat, out string text) { text = null; if (Class.Source.Cloneable != BaseNode.CloneableStatus.Single) { return(false); } string ClassTypeText = Type2CSharpString(usingCollection, cSharpTypeFormat, cSharpNamespaceFormat); text = $"{ClassTypeText}.Singleton"; return(true); }
/// <summary> /// Gets the source code corresponding to the qualified name. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="skippedAtEnd">Number of identifiers to skip at the end.</param> public string CSharpText(ICSharpUsingCollection usingCollection, int skippedAtEnd) { string Result; int i = 0; /* * if (Context.AttachmentAliasTable.ContainsKey(ValidPath.Item[i].ValidText.Item)) * { * Result = Context.AttachmentAliasTable[ValidPath.Item[i].ValidText.Item]; * i++; * } * else*/ Result = string.Empty; for (; i + skippedAtEnd < Source.ValidPath.Item.Count; i++) { if (Result.Length > 0) { Result += "."; } IIdentifier Item = Source.ValidPath.Item[i]; ICSharpClass ItemClass = i < ClassPath.Count ? ClassPath[i] : null; string ItemText = Item.ValidText.Item; if (i == 0 && usingCollection.AttachmentMap.ContainsKey(Item.ValidText.Item)) { ItemText = usingCollection.AttachmentMap[ItemText]; } else { ItemText = CSharpNames.ToCSharpIdentifier(ItemText); } if (ItemClass != null) { if (ItemClass.IsUnparameterizedSingleton && ItemClass.ValidSourceName != "Microsoft .NET") { string TypeText = ItemClass.Type.Type2CSharpString(usingCollection, CSharpTypeFormats.Normal, CSharpNamespaceFormats.None); ItemText = $"{TypeText}.Singleton"; } } Result += ItemText; } return(Result); }
/// <summary> /// Gets the source code corresponding to the qualified name. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="skippedAtEnd">Number of identifiers to skip at the end.</param> public string DecoratedCSharpText(ICSharpUsingCollection usingCollection, int skippedAtEnd) { string Result = null; string QueryText = CSharpText(usingCollection, skippedAtEnd); if (Discrete != null) { Result = QueryText; } else { switch (Feature) { case ICSharpPropertyFeature AsPropertyFeature: if (AsPropertyFeature.HasSideBySideAttribute || InheritBySideAttribute) { Result = $"_{QueryText}"; } else { Result = QueryText; } break; case ICSharpAttributeFeature AsAttributeFeature: case ICSharpConstantFeature AsConstantFeature: case ICSharpScopeAttributeFeature AsScopeAttributeFeature: Result = QueryText; break; case ICSharpFunctionFeature AsFunctionFeature: case ICSharpCreationFeature AsCreationFeature: case ICSharpProcedureFeature AsProcedureFeature: Result = $"{QueryText}()"; break; } } Debug.Assert(Result != null); return(Result); }
private string CSharpTextProperty(ICSharpUsingCollection usingCollection, ICSharpPropertyFeature feature) { string Result; string BaseTypeText; if (BaseType != null) { BaseTypeText = EffectiveBaseType.Type2CSharpString(usingCollection, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.OneWord); } else { BaseTypeText = $"I{CSharpNames.ToCSharpIdentifier(Delegated.Owner.ValidClassName)}"; } Result = $"({BaseTypeText} agentBase) => {{ return agentBase.{CSharpNames.ToCSharpIdentifier(Delegated.Name)}; }}"; return(Result); }
/// <summary> /// Gets the source code corresponding to the qualified name setter. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> public string CSharpSetter(ICSharpUsingCollection usingCollection) { string StartText; if (Source.ValidPath.Item.Count > 1) { StartText = CSharpText(usingCollection, 1); StartText += "."; } else { StartText = string.Empty; } IIdentifier Item = Source.ValidPath.Item[0]; string ItemText = CSharpNames.ToCSharpIdentifier(Item.ValidText.Item); string SetterText = $"{StartText}Set_{ItemText}"; return(SetterText); }
private string CSharpTextFunction(ICSharpUsingCollection usingCollection, ICSharpFunctionFeature feature) { string Result; // TODO handle several overloads. Debug.Assert(feature.OverloadList.Count > 0); ICSharpQueryOverload Overload = feature.OverloadList[0] as ICSharpQueryOverload; Debug.Assert(Overload != null); string BaseTypeText; if (BaseType != null) { BaseTypeText = EffectiveBaseType.Type2CSharpString(usingCollection, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.OneWord); } else { BaseTypeText = $"I{CSharpNames.ToCSharpIdentifier(Delegated.Owner.ValidClassName)}"; } string AgentParameters; string ParameterNameListText; if (Overload.ParameterList.Count > 0) { CSharpArgument.BuildParameterList(usingCollection, Overload.ParameterList, out string ParameterListText, out ParameterNameListText); AgentParameters = $"({BaseTypeText} agentBase, {ParameterListText})"; } else { AgentParameters = $"({BaseTypeText} agentBase)"; ParameterNameListText = string.Empty; } Result = $"{AgentParameters} => {{ return agentBase.{CSharpNames.ToCSharpIdentifier(Delegated.Name)}({ParameterNameListText}); }}"; return(Result); }
private static void BuildResultListWithResult(ICSharpUsingCollection usingCollection, IList <ICSharpParameter> resultList, int resultIndex, ref string parameterListText, ref string parameterNameListText, out string resultTypeText) { resultTypeText = null; for (int i = 0; i < resultList.Count; i++) { ICSharpParameter Result = resultList[i]; ICSharpScopeAttributeFeature ResultAttribute = Result.Feature; ICSharpType ParameterType = ResultAttribute.Type; CSharpTypeFormats ParameterFormat = ParameterType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string TypeString = ParameterType.Type2CSharpString(usingCollection, ParameterFormat, CSharpNamespaceFormats.None); string AttributeString = CSharpNames.ToCSharpIdentifier(Result.Name); if (i == resultIndex) { resultTypeText = TypeString; } else { if (parameterListText.Length > 0) { parameterListText += ", "; } if (parameterNameListText.Length > 0) { parameterNameListText += ", "; } parameterListText += $"out {TypeString} {AttributeString}"; parameterNameListText += $"out {AttributeString}"; } } Debug.Assert(resultTypeText != null); }
/// <summary> /// Get the name of a type. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="cSharpTypeFormat">The type format.</param> /// <param name="cSharpNamespaceFormat">The namespace format.</param> public override string Type2CSharpString(ICSharpUsingCollection usingCollection, CSharpTypeFormats cSharpTypeFormat, CSharpNamespaceFormats cSharpNamespaceFormat) { SetUsedInCode(); string Result; // TODO: detect delegate call parameters to select the proper overload if (OriginatingTypedef != null) { string DelegateName = CSharpNames.ToCSharpIdentifier(OriginatingTypedef.Name); Result = CommandOverloadType2CSharpString(DelegateName, Source.OverloadList[0]); } else { ICSharpCommandOverloadType OverloadType = OverloadTypeList[0]; string ActionArgumentText = BaseType.Type2CSharpString(usingCollection, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None); foreach (ICSharpParameter Parameter in OverloadType.ParameterList) { ICSharpType ParameterType = Parameter.Feature.Type; CSharpTypeFormats ParameterFormat = ParameterType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string ParameterText = ParameterType.Type2CSharpString(usingCollection, ParameterFormat, CSharpNamespaceFormats.None); ActionArgumentText += $", {ParameterText}"; } Result = $"Action<{ActionArgumentText}>"; usingCollection.AddUsing(nameof(System)); } return(Result); }
/// <summary> /// Gets the string corresponding to the enumeration of C# generic arguments. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="typeArgumentList">The list of arguments.</param> /// <param name="isWithInterface">If true, include the interface type.</param> /// <param name="isWithImplementation">If true, include the implementation type.</param> protected static string TypeArguments2CSharpName(ICSharpUsingCollection usingCollection, IList <ICSharpType> typeArgumentList, bool isWithInterface, bool isWithImplementation) { Debug.Assert(isWithInterface || isWithImplementation); string GenericNames = string.Empty; foreach (ICSharpType TypeArgument in typeArgumentList) { if (GenericNames.Length > 0) { GenericNames += ", "; } if (isWithInterface) { GenericNames += TypeArgument.Type2CSharpString(usingCollection, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None); } if (isWithImplementation) { if (isWithInterface) { GenericNames += "," + " "; } GenericNames += TypeArgument.Type2CSharpString(usingCollection, CSharpTypeFormats.Normal, CSharpNamespaceFormats.None); } } if (GenericNames.Length > 0) { GenericNames = "<" + GenericNames + ">"; } return(GenericNames); }
/// <summary> /// Get the name of a type. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="cSharpTypeFormat">The type format.</param> /// <param name="cSharpNamespaceFormat">The namespace format.</param> public override string Type2CSharpString(ICSharpUsingCollection usingCollection, CSharpTypeFormats cSharpTypeFormat, CSharpNamespaceFormats cSharpNamespaceFormat) { SetUsedInCode(); Debug.Assert(Class != null); Debug.Assert(Class.Source != null); Guid BaseClassGuid = Class.Source.ClassGuid; bool AsInterface = cSharpTypeFormat == CSharpTypeFormats.AsInterface; bool TypeArgumentsWithInterface = true; bool TypeArgumentsWithImplementation = false; string Result = null; if (BaseClassGuid == LanguageClasses.BitFieldEnumeration.Guid) { Result = CSharpNames.ToCSharpIdentifier(Class.ValidClassName); } else if (BaseClassGuid == LanguageClasses.DetachableReference.Guid) { Result = "DetachableReference" + TypeArguments2CSharpName(usingCollection, TypeArgumentList, TypeArgumentsWithInterface, TypeArgumentsWithImplementation); } else if (BaseClassGuid == LanguageClasses.Hashtable.Guid) { Result = "Hashtable" + TypeArguments2CSharpName(usingCollection, TypeArgumentList, TypeArgumentsWithInterface, TypeArgumentsWithImplementation); } else if (BaseClassGuid == LanguageClasses.KeyValuePair.Guid) { Result = "KeyValuePair" + TypeArguments2CSharpName(usingCollection, TypeArgumentList, TypeArgumentsWithInterface, TypeArgumentsWithImplementation); } else if (BaseClassGuid == LanguageClasses.List.Guid) { string ClassName; if (AsInterface) { ClassName = "IList"; } else { ClassName = "List"; } Result = ClassName + TypeArguments2CSharpName(usingCollection, TypeArgumentList, TypeArgumentsWithInterface, TypeArgumentsWithImplementation); usingCollection.AddUsing("System.Collections.Generic"); } else if (BaseClassGuid == LanguageClasses.OnceReference.Guid) { Result = "OnceReference" + TypeArguments2CSharpName(usingCollection, TypeArgumentList, TypeArgumentsWithInterface, TypeArgumentsWithImplementation); } else if (BaseClassGuid == LanguageClasses.OptionalReference.Guid) { Result = "OptionalReference" + TypeArguments2CSharpName(usingCollection, TypeArgumentList, TypeArgumentsWithInterface, TypeArgumentsWithImplementation); } else if (BaseClassGuid == LanguageClasses.OverLoopSource.Guid) { Result = "Enumerable" + TypeArguments2CSharpName(usingCollection, TypeArgumentList, TypeArgumentsWithInterface, TypeArgumentsWithImplementation); } else if (BaseClassGuid == LanguageClasses.SealableHashtable.Guid) { Result = "Hashtable" + TypeArguments2CSharpName(usingCollection, TypeArgumentList, TypeArgumentsWithInterface, TypeArgumentsWithImplementation); } else if (BaseClassGuid == LanguageClasses.SpecializedTypeEntity.Guid) { Result = "SpecializedTypeEntity" + TypeArguments2CSharpName(usingCollection, TypeArgumentList, false, true); } else if (BaseClassGuid == LanguageClasses.StableReference.Guid) { Result = "StableReference" + TypeArguments2CSharpName(usingCollection, TypeArgumentList, TypeArgumentsWithInterface, TypeArgumentsWithImplementation); } else if (LanguageClasses.GuidToName.ContainsKey(BaseClassGuid)) { Result = null; if (BaseClassGuid == LanguageClasses.Number.Guid) { Debug.Assert(Source.NumberKind != NumberKinds.NotChecked && Source.NumberKind != NumberKinds.NotApplicable); if (Source.NumberKind == NumberKinds.Integer) { Result = "int"; } else if (Source.NumberKind == NumberKinds.Real) { Result = "double"; } } if (Result == null) { Result = CSharpLanguageClasses.GuidToName[BaseClassGuid]; } if (CSharpLanguageClasses.NameUsingTable.ContainsKey(Result)) { string UsingDirective = CSharpLanguageClasses.NameUsingTable[Result]; usingCollection.AddUsing(UsingDirective); } } else { string ClassName; if (Class.Source.IsEnumeration) { cSharpTypeFormat = CSharpTypeFormats.Normal; } ClassName = Class.BasicClassName2CSharpClassName(usingCollection, cSharpTypeFormat, cSharpNamespaceFormat); Result = ClassName + TypeArguments2CSharpName(usingCollection, TypeArgumentList, true, true); } return(Result); }
/// <summary> /// Get the name of a type. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="cSharpTypeFormat">The type format.</param> /// <param name="cSharpNamespaceFormat">The namespace format.</param> public override string Type2CSharpString(ICSharpUsingCollection usingCollection, CSharpTypeFormats cSharpTypeFormat, CSharpNamespaceFormats cSharpNamespaceFormat) { SetUsedInCode(); string Result; if (OriginatingTypedef != null) { // TODO: detect delegate call parameters to select the proper overload string DelegateName = CSharpNames.ToCSharpIdentifier(OriginatingTypedef.Name); Result = QueryOverloadType2CSharpString(DelegateName, Source.OverloadList[0]); } else { ICSharpQueryOverloadType OverloadType = OverloadTypeList[0]; string ActionArgumentText = BaseType.Type2CSharpString(usingCollection, CSharpTypeFormats.AsInterface, CSharpNamespaceFormats.None); foreach (ICSharpParameter Parameter in OverloadType.ParameterList) { ICSharpType ParameterType = Parameter.Feature.Type; CSharpTypeFormats ParameterFormat = ParameterType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string ParameterText = ParameterType.Type2CSharpString(usingCollection, ParameterFormat, CSharpNamespaceFormats.None); ActionArgumentText += $", {ParameterText}"; } Debug.Assert(OverloadType.ResultList.Count >= 1); if (OverloadType.ResultList.Count == 1) { ICSharpParameter Parameter = OverloadType.ResultList[0]; ICSharpType ResultType = Parameter.Feature.Type; CSharpTypeFormats ResultFormat = ResultType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string ResultText = ResultType.Type2CSharpString(usingCollection, ResultFormat, CSharpNamespaceFormats.None); ActionArgumentText += $", {ResultText}"; } else { string FuncResultText = string.Empty; foreach (ICSharpParameter Parameter in OverloadType.ResultList) { if (FuncResultText.Length > 0) { FuncResultText += ", "; } ICSharpType ResultType = Parameter.Feature.Type; CSharpTypeFormats ResultFormat = ResultType.HasInterfaceText ? CSharpTypeFormats.AsInterface : CSharpTypeFormats.Normal; string ResultText = ResultType.Type2CSharpString(usingCollection, ResultFormat, CSharpNamespaceFormats.None); FuncResultText += $", {ResultText}"; } ActionArgumentText += $", Tuple<{FuncResultText}>"; } Result = $"Func<{ActionArgumentText}>"; usingCollection.AddUsing(nameof(System)); } return(Result); }
/// <summary> /// Get the name of a type. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="cSharpTypeFormat">The type format.</param> /// <param name="cSharpNamespaceFormat">The namespace format.</param> public override string Type2CSharpString(ICSharpUsingCollection usingCollection, CSharpTypeFormats cSharpTypeFormat, CSharpNamespaceFormats cSharpNamespaceFormat) { SetUsedInCode(); return("<Not Supported>"); }
/// <summary> /// Gets the singleton text corresponding to this type, if any. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="cSharpTypeFormat">The type format.</param> /// <param name="cSharpNamespaceFormat">The namespace format.</param> /// <param name="text">The singleton text upon return, if successful.</param> public virtual bool GetSingletonString(ICSharpUsingCollection usingCollection, CSharpTypeFormats cSharpTypeFormat, CSharpNamespaceFormats cSharpNamespaceFormat, out string text) { text = null; return(false); }
/// <summary> /// Get the name of a type. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="cSharpTypeFormat">The type format.</param> /// <param name="cSharpNamespaceFormat">The namespace format.</param> public abstract string Type2CSharpString(ICSharpUsingCollection usingCollection, CSharpTypeFormats cSharpTypeFormat, CSharpNamespaceFormats cSharpNamespaceFormat);
/// <summary> /// Get the name of a type. /// </summary> /// <param name="usingCollection">The collection of using directives.</param> /// <param name="cSharpTypeFormat">The type format.</param> /// <param name="cSharpNamespaceFormat">The namespace format.</param> public override string Type2CSharpString(ICSharpUsingCollection usingCollection, CSharpTypeFormats cSharpTypeFormat, CSharpNamespaceFormats cSharpNamespaceFormat) { SetUsedInCode(); return(((cSharpTypeFormat == CSharpTypeFormats.AsInterface) ? "I" : string.Empty) + CSharpNames.ToCSharpIdentifier(Generic.Name)); }