public static CodeSnippetTypeMember CreateCast(string typeT, string typeT1, bool useAutoTyping, string @namespace = "",
GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public)
{
CodeSnippetTypeMember castMember = new CodeSnippetTypeMember();
@namespace = @namespace.IsNotEmpty() ? $"{@namespace}." : "";
var visibilityKeyword = visibility.ToKeyword();
var servicesClassName = @namespace + NameGenerator.GetServicesClassName();
if (useAutoTyping)
{
castMember.Text = String.Concat($"\t\t{visibilityKeyword} static explicit operator ", typeT, "(XElement xe) { ",
"return (", typeT, ")", Constants.XTypedServices, ".ToXTypedElement(xe,",
servicesClassName, ".Instance as ILinqToXsdTypeManager); }");
}
else
{
castMember.Text = String.Concat($"\t\t{visibilityKeyword} static explicit operator ", typeT,
"(XElement xe) { return ", Constants.XTypedServices, ".ToXTypedElement<",
GetInnerType(typeT, typeT1), ">(xe,", servicesClassName,
".Instance as ILinqToXsdTypeManager); }");
}
return(castMember);
}
public static TypePropertyBuilder Create(GroupingInfo groupingInfo, CodeTypeDeclaration decl,
CodeTypeDeclItems declItems, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public)
{
switch (groupingInfo.ContentModelType)
{
case ContentModelType.None:
case ContentModelType.All:
return(new DefaultPropertyBuilder(decl, declItems, visibility));
case ContentModelType.Sequence:
if (groupingInfo.IsComplex)
{
return(new DefaultPropertyBuilder(decl, declItems, visibility));
}
return(new SequencePropertyBuilder(groupingInfo, decl, declItems, visibility));
case ContentModelType.Choice:
if (groupingInfo.IsComplex)
{
return(new DefaultPropertyBuilder(decl, declItems, visibility));
}
return(new ChoicePropertyBuilder(groupingInfo, decl, declItems, visibility));
default:
throw new InvalidOperationException();
}
}
public ContentModelPropertyBuilder(ContentModelPropertyBuilder parentBuilder, GroupingInfo grouping, CodeTypeDeclaration decl, CodeTypeDeclItems declItems,
GeneratedTypesVisibility visibility)
: base(decl, declItems, visibility)
{
this.ParentBuilder = parentBuilder;
this.grouping = grouping; //The grouping the contentmodelbuilder works on
}
/// <summary>
/// Creates a new <see cref="Namespace"/> instance from given values. Defaults to <see cref="GeneratedTypesVisibility.Public"/> <paramref name="visibility"/>.
/// </summary>
/// <param name="schemaUri"></param>
/// <param name="clrNamespace"></param>
/// <param name="visibility"></param>
/// <returns></returns>
public static Namespace New(string schemaUri, string clrNamespace, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public)
{
return(new Namespace {
DefaultVisibility = visibility.ToKeyword(),
Schema = schemaUri.IsEmpty() ? null : new Uri(schemaUri),
Clr = clrNamespace
});
}
public static CodeTypeDeclaration CreateTypeDeclaration(string clrTypeName, string innerType,
GeneratedTypesVisibility generatedTypesVisibility = GeneratedTypesVisibility.Public)
{
CodeTypeDeclaration typeDecl = new CodeTypeDeclaration(clrTypeName);
typeDecl.TypeAttributes = generatedTypesVisibility.ToTypeAttribute();
typeDecl.IsPartial = true;
return(typeDecl);
}
public static CodeSnippetTypeMember CreateXRootGetter(string typeName, string fqTypeName, LocalSymbolTable lst,
GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public)
{
string symbolName = lst.AddMember(typeName);
CodeSnippetTypeMember castMember = new CodeSnippetTypeMember();
castMember.Text = String.Concat("\r\n", $"\t\t{visibility.ToKeyword()} ", fqTypeName, " ", symbolName, " { get {",
"return rootObject as ", fqTypeName, "; } }");
return(castMember);
}
public ChoicePropertyBuilder(ContentModelPropertyBuilder parentBuilder, GroupingInfo grouping, CodeTypeDeclaration decl, CodeTypeDeclItems declItems,
GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) :
base(parentBuilder, grouping, decl, declItems, visibility)
{
flatChoice = !grouping.IsNested && !grouping.IsRepeating && !grouping.HasChildGroups;
hasDuplicateType = false;
if (flatChoice)
{
propertyTypeNameTable = new Dictionary <string, ClrBasePropertyInfo>();
}
}
public static CodeTypeMember CreateSave(string paramName, string paramType, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public)
{
CodeMemberMethod saveMethod = new CodeMemberMethod();
saveMethod.Name = "Save";
saveMethod.Attributes = (saveMethod.Attributes & ~MemberAttributes.AccessMask) | visibility.ToMemberAttribute();
saveMethod.Parameters.Add(CreateParameter(paramName, paramType));
saveMethod.Statements.Add(
CreateMethodCall(
new CodeTypeReferenceExpression(Constants.XTypedServices),
"Save",
new CodeVariableReferenceExpression(paramName),
new CodePropertyReferenceExpression(null, Constants.Untyped)));
return(saveMethod);
}
public static CodeMemberMethod CreateXRootSave(string[][] paramList, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public)
{
CodeMemberMethod staticMethod = new CodeMemberMethod();
staticMethod.Name = "Save";
staticMethod.Attributes = visibility.ToMemberAttribute();
CodeExpression[] parameterExp = new CodeExpression[paramList.Length];
for (int i = 0; i < paramList.Length; i++)
{
string[] paramRef = paramList[i];
// index 0 is the type name and index 1 is the parameter name
staticMethod.Parameters.Add(CreateParameter(paramRef[1], paramRef[0]));
parameterExp[i] = new CodeVariableReferenceExpression(paramRef[1]);
}
CodeExpression doc = new CodeVariableReferenceExpression("doc");
staticMethod.Statements.Add( //root.doc = XDocument.Save(...);
CreateMethodCall(doc, "Save", parameterExp));
return(staticMethod);
}
public static CodeMemberMethod CreateInterfaceImplMethod(string methodName, string interfaceName,
CodeTypeReference returnType, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public)
{
CodeMemberMethod interfaceMethod = CreateMethod(methodName, returnType, visibility.ToMemberAttribute());
interfaceMethod.PrivateImplementationType = new CodeTypeReference(interfaceName);
interfaceMethod.ImplementationTypes.Add(new CodeTypeReference(interfaceName));
return(interfaceMethod);
}
public static CodeTypeMember CreateStaticMethod(string methodName, string typeT, string typeT1,
string parameterName, string parameterType, bool useAutoTyping, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public)
{
CodeMemberMethod staticMethod = new CodeMemberMethod();
staticMethod.Name = methodName;
staticMethod.Attributes = MemberAttributes.Static | visibility.ToMemberAttribute();
staticMethod.ReturnType = new CodeTypeReference(typeT);
staticMethod.Parameters.Add(CreateParameter(parameterName, parameterType));
CodeExpression parameterExp = new CodeVariableReferenceExpression(parameterName);
if (useAutoTyping)
{
staticMethod.Statements.Add(
new CodeMethodReturnStatement(
new CodeCastExpression(
staticMethod.ReturnType,
CreateMethodCall(
new CodeTypeReferenceExpression(Constants.XTypedServices),
Constants.ToXTypedElement,
CreateMethodCall(new CodeTypeReferenceExpression(Constants.XElement),
methodName, parameterExp),
CodeDomHelper.SingletonTypeManager()))));
}
else
{
CodeMethodInvokeExpression methodCall = CreateMethodCall(
new CodeTypeReferenceExpression(Constants.XTypedServices),
methodName + "<" + GetInnerType(typeT, typeT1) + ">", parameterExp);
if (typeT1 != null)
{
methodCall.Parameters.Add(CodeDomHelper.SingletonTypeManager());
}
staticMethod.Statements.Add(new CodeMethodReturnStatement(methodCall));
}
return(staticMethod);
}
public static TypePropertyBuilder Create(CodeTypeDeclaration decl, CodeTypeDeclItems declItems,
GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public)
{
return(new DefaultPropertyBuilder(decl, declItems, visibility));
}
internal DefaultPropertyBuilder(CodeTypeDeclaration decl, CodeTypeDeclItems declItems,
GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) : base(decl, declItems, visibility)
{
}
public TypePropertyBuilder(CodeTypeDeclaration decl, CodeTypeDeclItems declItems, GeneratedTypesVisibility visibility)
{
this.decl = decl;
this.declItems = declItems;
this.visibility = visibility;
}
public SequencePropertyBuilder(ContentModelPropertyBuilder parentBuilder, GroupingInfo grouping, CodeTypeDeclaration decl, CodeTypeDeclItems declItems,
GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) :
base(parentBuilder, grouping, decl, declItems, visibility)
{
}
/// <summary> /// Converts <see cref="GeneratedTypesVisibility"/> to an appropriate <see cref="TypeAttributes"/> instance. /// </summary> /// <param name="gtv"></param> /// <returns></returns> public static TypeAttributes ToTypeAttribute(this GeneratedTypesVisibility gtv) => gtv.HasFlag(GeneratedTypesVisibility.Internal) || gtv == GeneratedTypesVisibility.Internal ? TypeAttributes.NestedAssembly : TypeAttributes.Public;
public static CodeMemberMethod CreateXRootMethod(string returnType, string methodName, string[][] paramList,
GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public)
{
CodeTypeReference xRootType = new CodeTypeReference(returnType);
CodeMemberMethod staticMethod = new CodeMemberMethod();
staticMethod.Name = methodName;
staticMethod.Attributes = visibility.ToMemberAttribute() | MemberAttributes.Static;
staticMethod.ReturnType = xRootType;
CodeExpression[] parameterExp = new CodeExpression[paramList.Length];
for (int i = 0; i < paramList.Length; i++)
{
string[] paramRef = paramList[i];
// index 0 is the type name and index 1 is the parameter name
staticMethod.Parameters.Add(CreateParameter(paramRef[1], paramRef[0]));
parameterExp[i] = new CodeVariableReferenceExpression(paramRef[1]);
}
CodeExpression rootExp = new CodeVariableReferenceExpression("root");
CodeExpression doc = new CodeFieldReferenceExpression(rootExp, "doc");
staticMethod.Statements.Add( //XRoot root = new XRoot;
new CodeVariableDeclarationStatement(xRootType, "root",
new CodeObjectCreateExpression(xRootType)));
staticMethod.Statements.Add( //root.doc = XDocument.Load(xmlFile);
new CodeAssignStatement(
doc,
CreateMethodCall(new CodeTypeReferenceExpression("XDocument"), methodName,
parameterExp)));
staticMethod.Statements.Add( //XTypedElement typedRoot = XTypedServices.ToXTypedElement(....)
new CodeVariableDeclarationStatement(
Constants.XTypedElement,
"typedRoot",
CreateMethodCall(
new CodeTypeReferenceExpression(Constants.XTypedServices),
Constants.ToXTypedElement,
new CodePropertyReferenceExpression(doc, "Root"),
CodeDomHelper.SingletonTypeManager())));
staticMethod.Statements.Add( //if(typedRoot == null)
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodeVariableReferenceExpression("typedRoot"),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(null)
),
new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(Constants.LinqToXsdException,
new CodePrimitiveExpression("Invalid root element in xml document."))
)));
staticMethod.Statements.Add( //root.rootObject = typedRoot
new CodeAssignStatement(
new CodeFieldReferenceExpression(rootExp, "rootObject"),
new CodeVariableReferenceExpression("typedRoot")));
staticMethod.Statements.Add( //return root;
new CodeMethodReturnStatement(rootExp));
return(staticMethod);
}
/// <summary>
/// Converts <see cref="GeneratedTypesVisibility"/> to an appropriate <see cref="MemberAttributes"/> instance.
/// </summary>
/// <param name="gtv"></param>
/// <returns></returns>
public static MemberAttributes ToMemberAttribute(this GeneratedTypesVisibility gtv) =>
gtv.HasFlag(GeneratedTypesVisibility.Internal) || gtv == GeneratedTypesVisibility.Internal
? MemberAttributes.Assembly
: MemberAttributes.Public;
public static CodeConstructor CreateXRootFunctionalConstructor(string typeName, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public)
{
CodeConstructor constructor = CodeDomHelper.CreateConstructor(visibility.ToMemberAttribute());
constructor.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeName), "root"));
constructor.Statements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(This(), "doc"),
new CodeObjectCreateExpression(
"XDocument",
new CodePropertyReferenceExpression(
new CodeVariableReferenceExpression("root"),
Constants.Untyped))));
constructor.Statements.Add(
new CodeAssignStatement(
new CodeFieldReferenceExpression(This(), "rootObject"),
new CodeVariableReferenceExpression("root")));
return(constructor);
}
/// <summary> /// Converts <see cref="GeneratedTypesVisibility"/> to a keyword for use in code-generation. /// </summary> /// <param name="gtv"></param> /// <returns></returns> public static string ToKeyword(this GeneratedTypesVisibility gtv) => gtv.HasFlag(GeneratedTypesVisibility.Internal) || gtv == GeneratedTypesVisibility.Internal ? "internal" : "public";
private void CreateXRoot(CodeNamespace codeNamespace, string rootName, List <CodeTypeDeclaration> elements,
List <CodeNamespace> namespaces, GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public)
{
LocalSymbolTable lst = new LocalSymbolTable();
CodeTypeDeclaration xroot = CodeDomHelper.CreateTypeDeclaration(rootName, null, visibility);
//Create Methods
CodeMemberField docField = CodeDomHelper.CreateMemberField("doc",
"XDocument",
false, MemberAttributes.Private);
CodeMemberField rootField = CodeDomHelper.CreateMemberField("rootObject",
Constants.XTypedElement,
false, MemberAttributes.Private);
xroot.Members.Add(docField);
xroot.Members.Add(rootField);
lst.Init(rootName);
lst.RegisterMember("doc");
lst.RegisterMember("rootObject");
lst.RegisterMember("Load");
lst.RegisterMember("Parse");
lst.RegisterMember("Save");
lst.RegisterMember("XDocument");
lst.RegisterMember("Root");
// Constructor
xroot.Members.Add(CodeDomHelper.CreateConstructor(MemberAttributes.Private));
//Load Methods
xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load",
new string[][] { new string[] { "System.String", "xmlFile" } }, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load", new string[][]
{
new string[] { "System.String", "xmlFile" },
new string[] { "LoadOptions", "options" }
}, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load",
new string[][] { new string[] { "TextReader", "textReader" } }, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load", new string[][]
{
new string[] { "TextReader", "textReader" },
new string[] { "LoadOptions", "options" }
}, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Load",
new string[][] { new string[] { "XmlReader", "xmlReader" } }, visibility));
//Parse Methods
xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Parse",
new string[][] { new string[] { "System.String", "text" } }, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootMethod(rootName, "Parse", new string[][]
{
new string[] { "System.String", "text" },
new string[] { "LoadOptions", "options" }
}, visibility));
//Save Methods
xroot.Members.Add(
CodeDomHelper.CreateXRootSave(new string[][] { new string[] { "System.String", "fileName" } }, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootSave(new string[][]
{ new string[] { "TextWriter", "textWriter" } }, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootSave(new string[][] { new string[] { "XmlWriter", "writer" } }, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootSave(new string[][]
{
new string[] { "TextWriter", "textWriter" },
new string[] { "SaveOptions", "options" }
}, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootSave(new string[][]
{
new string[] { "System.String", "fileName" },
new string[] { "SaveOptions", "options" }
}, visibility));
CodeMemberProperty docProp = CodeDomHelper.CreateProperty("XDocument",
"XDocument",
docField,
visibility.ToMemberAttribute(),
false);
xroot.Members.Add(docProp);
CodeMemberProperty rootProp = CodeDomHelper.CreateProperty("Root",
"XTypedElement",
rootField,
visibility.ToMemberAttribute(),
false);
xroot.Members.Add(rootProp);
for (int i = 0; i < elements.Count; i++)
{
string typeName = elements[i].Name;
string fqTypeName = (namespaces == null || namespaces[i].Name == String.Empty)
? typeName
: "global::" + namespaces[i].Name + "." + typeName;
xroot.Members.Add(CodeDomHelper.CreateXRootFunctionalConstructor(fqTypeName, visibility));
xroot.Members.Add(CodeDomHelper.CreateXRootGetter(typeName, fqTypeName, lst, visibility));
}
codeNamespace.Types.Add(xroot);
}
public SequencePropertyBuilder(GroupingInfo grouping, CodeTypeDeclaration decl, CodeTypeDeclItems declItems,
GeneratedTypesVisibility visibility = GeneratedTypesVisibility.Public) :
base(grouping, decl, declItems, visibility)
{
}
