public CodeMemberMethod GenerateFromXmlMethod()
{
CodeMemberMethod fromXmlMethod = new CodeMemberMethod();
fromXmlMethod.Name = FromXmlMethodName;
fromXmlMethod.Attributes = MemberAttributes.Final | MemberAttributes.Public|MemberAttributes.Static;
CodeTypeParameter tTypeParameter = new CodeTypeParameter("T");
//tType.HasConstructorConstraint = true;
fromXmlMethod.TypeParameters.Add(tTypeParameter);
fromXmlMethod.ReturnType = new CodeTypeReference("T");;
//fromXmlMethod.Statements.Add();
fromXmlMethod.Parameters.Add(new CodeParameterDeclarationExpression(
new CodeTypeReference("String"), "xml"));
fromXmlMethod.Comments.Add(new CodeCommentStatement("Call it using this code: YourStrongTypedEntity entity = FromXml<YourStrongTypedEntity>(YourMsgString);"));
fromXmlMethod.Statements.Add(new CodeSnippetStatement(@" T returnedXmlClass = default(T);
using (TextReader reader = new StringReader(xml))
{
returnedXmlClass = (T)new XmlSerializer(typeof(T)).Deserialize(reader);
}
return returnedXmlClass ; "));
return fromXmlMethod;
}
public static CodeMemberMethod Generic(this CodeMemberMethod method, string paramName,
params Type[] constraints)
{
var p = new CodeTypeParameter(paramName);
p.Constraints.AddRange(constraints.Select((t) => new CodeTypeReference(t)).ToArray());
method.TypeParameters.Add(p);
return method;
}
public void AddRange(CodeTypeParameter[] value) {
if (value == null) {
throw new ArgumentNullException("value");
}
for (int i = 0; ((i) < (value.Length)); i = ((i) + (1))) {
this.Add(value[i]);
}
}
public static CodeTypeDeclaration Generic(this CodeTypeDeclaration @class, string paramName,
params Type[] constraints)
{
var p = new CodeTypeParameter(paramName);
p.Constraints.AddRange(constraints.Select((t) => new CodeTypeReference(t)).ToArray());
@class.TypeParameters.Add(p);
return @class;
}
public void Constructor1_NullItem ()
{
CodeTypeParameter[] typeParams = new CodeTypeParameter[] {
new CodeTypeParameter (), null };
CodeTypeParameterCollection coll = new CodeTypeParameterCollection (
typeParams);
}
public CodeTypeParameter ToCodeDom()
{
CodeTypeParameter typeParameter = new CodeTypeParameter(this.Name);
typeParameter.CustomAttributes.AddRange(this.CustomAttributes.ToCodeDom());
foreach (ITypeDeclaration constraint in this.Constraints)
typeParameter.Constraints.Add(constraint.TypeReference);
return typeParameter;
}
public static CodeMemberMethod Generic(this CodeMemberMethod method, string paramName,
bool hasConstructor, params CodeTypeReference[] constraints)
{
var p = new CodeTypeParameter(paramName) {HasConstructorConstraint = hasConstructor};
p.Constraints.AddRange(constraints);
method.TypeParameters.Add(p);
return method;
}
public void AddRange (CodeTypeParameter[] value)
{
if (value == null) {
throw new ArgumentNullException ("value");
}
for (int i = 0; i < value.Length; i++) {
Add (value[i]);
}
}
public void Constructor1_Deny_Unrestricted ()
{
CodeTypeParameter ctp = new CodeTypeParameter ("mono");
Assert.AreEqual (0, ctp.Constraints.Count, "Constraints");
Assert.AreEqual (0, ctp.CustomAttributes.Count, "CustomAttributes");
Assert.IsFalse (ctp.HasConstructorConstraint, "HasConstructorConstraint");
ctp.HasConstructorConstraint = true;
Assert.AreEqual ("mono", ctp.Name);
ctp.Name = String.Empty;
}
public string Evaluate(CodeTypeParameter codeTypeParameter)
{
var typeParameterConstraint = string.Empty;
if (codeTypeParameter.Constraints.Count > 0)
{
var constraint = codeTypeParameter.Constraints.OfType<CodeTypeReference>().First();
var type = _typescriptTypeMapper.GetTypeOutput(constraint);
typeParameterConstraint = $" extends {type}";
}
return $"{codeTypeParameter.Name}{typeParameterConstraint}";
}
public void Constructor1 ()
{
CodeTypeParameter tp1 = new CodeTypeParameter ();
CodeTypeParameter tp2 = new CodeTypeParameter ();
CodeTypeParameter[] typeParams = new CodeTypeParameter[] { tp1, tp2 };
CodeTypeParameterCollection coll = new CodeTypeParameterCollection (
typeParams);
Assert.AreEqual (2, coll.Count, "#1");
Assert.AreEqual (0, coll.IndexOf (tp1), "#2");
Assert.AreEqual (1, coll.IndexOf (tp2), "#3");
}
public void Constructor2 ()
{
CodeTypeParameter tp1 = new CodeTypeParameter ();
CodeTypeParameter tp2 = new CodeTypeParameter ();
CodeTypeParameterCollection c = new CodeTypeParameterCollection ();
c.Add (tp1);
c.Add (tp2);
CodeTypeParameterCollection coll = new CodeTypeParameterCollection (c);
Assert.AreEqual (2, coll.Count, "#1");
Assert.AreEqual (0, coll.IndexOf (tp1), "#2");
Assert.AreEqual (1, coll.IndexOf (tp2), "#3");
}
public void Constructor1 () {
string parameterName = "mono";
CodeTypeParameter ctp = new CodeTypeParameter (parameterName);
Assert.IsNotNull (ctp.Constraints, "#1");
Assert.AreEqual (0, ctp.Constraints.Count, "#2");
Assert.IsNotNull (ctp.CustomAttributes, "#3");
Assert.AreEqual (0, ctp.CustomAttributes.Count, "#4");
Assert.IsFalse (ctp.HasConstructorConstraint, "#5");
Assert.IsNotNull (ctp.Name, "#6");
Assert.AreSame (parameterName, ctp.Name, "#7");
ctp.Name = null;
Assert.IsNotNull (ctp.Name, "#8");
Assert.AreEqual (string.Empty, ctp.Name, "#9");
ctp = new CodeTypeParameter ((string) null);
Assert.IsNotNull (ctp.Name, "#10");
Assert.AreEqual (string.Empty, ctp.Name, "#11");
}
public CodeMemberMethod[] GetFindAllByNameExMethods()
{
string methodName = "FindAllByNameEx";
SAPAutomationHelper.Current.SetSAPApiAssembly();
Assembly asm = SAPAutomationHelper.Current.SAPGuiApiAssembly;
var interfaces = asm.GetTypes().Where(t => t.IsInterface && t.Name.StartsWith("Gui") && t.GetInterfaces()[0].GetMethod(methodName) != null).ToArray();
CodeMemberMethod[] methods = new CodeMemberMethod[interfaces.Count()];
for (int i = 0; i < interfaces.Count(); i++)
{
methods[i] = new CodeMemberMethod();
methods[i].Name = methodName;
methods[i].Attributes = MemberAttributes.Public | MemberAttributes.Static;
CodeParameterDeclarationExpression para1 = new CodeParameterDeclarationExpression(new CodeTypeReference("this " + interfaces[i].Name), interfaces[i].Name.Substring(3));
methods[i].Parameters.Add(para1);
CodeParameterDeclarationExpression para2 = new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(string)), "Name");
methods[i].Parameters.Add(para2);
CodeParameterDeclarationExpression para3 = new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "TypeId");
methods[i].Parameters.Add(para3);
methods[i].ReturnType = new CodeTypeReference("IEnumerable<T>");
CodeTypeParameter param = new CodeTypeParameter("T");
param.Constraints.Add(" class");
methods[i].TypeParameters.Add(param);
methods[i].Statements.Add(new CodeMethodReturnStatement(
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(null, "findAllByNameExTemplate", new CodeTypeReference("T")),
new CodeVariableReferenceExpression("Name"),
new CodeVariableReferenceExpression("TypeId"),
new CodeArgumentReferenceExpression(interfaces[i].Name.Substring(3) + "." + methodName)
)));
}
return methods;
}
public void Constructor0 ()
{
CodeTypeParameter ctp = new CodeTypeParameter ();
Assert.IsNotNull (ctp.Constraints, "#1");
Assert.AreEqual (0, ctp.Constraints.Count, "#2");
Assert.IsNotNull (ctp.CustomAttributes, "#3");
Assert.AreEqual (0, ctp.CustomAttributes.Count, "#4");
Assert.IsFalse (ctp.HasConstructorConstraint, "#5");
Assert.IsNotNull (ctp.Name, "#6");
Assert.AreEqual (string.Empty, ctp.Name, "#7");
ctp.Name = null;
Assert.IsNotNull (ctp.Name, "#8");
Assert.AreEqual (string.Empty, ctp.Name, "#9");
string name = "mono";
ctp.Name = name;
Assert.AreSame (name, ctp.Name, "#10");
ctp.HasConstructorConstraint = true;
Assert.IsTrue (ctp.HasConstructorConstraint, "#11");
}
public void Remove(CodeTypeParameter value)
{
throw new NotImplementedException();
}
public void Remove ()
{
CodeTypeParameter ctp1 = new CodeTypeParameter ();
CodeTypeParameter ctp2 = new CodeTypeParameter ();
CodeTypeParameterCollection coll = new CodeTypeParameterCollection ();
coll.Add (ctp1);
coll.Add (ctp2);
Assert.AreEqual (2, coll.Count, "#1");
Assert.AreEqual (0, coll.IndexOf (ctp1), "#2");
Assert.AreEqual (1, coll.IndexOf (ctp2), "#3");
coll.Remove (ctp1);
Assert.AreEqual (1, coll.Count, "#4");
Assert.AreEqual (-1, coll.IndexOf (ctp1), "#5");
Assert.AreEqual (0, coll.IndexOf (ctp2), "#6");
}
public int IndexOf(CodeTypeParameter value)
{
throw new NotImplementedException();
}
// Create a CodeDOM graph.
static void CreateGraph(CodeDomProvider provider, CodeCompileUnit cu)
{
//<Snippet8>
if (!provider.Supports(GeneratorSupport.GenericTypeReference |
GeneratorSupport.GenericTypeDeclaration))
{
// Return if the generator does not support generics.
return;
}
//</Snippet8>
CodeNamespace ns = new CodeNamespace("DemoNamespace");
ns.Imports.Add(new CodeNamespaceImport("System"));
ns.Imports.Add(new CodeNamespaceImport("System.Collections.Generic"));
cu.Namespaces.Add(ns);
// Declare a generic class.
CodeTypeDeclaration class1 = new CodeTypeDeclaration();
class1.Name = "MyDictionary";
class1.BaseTypes.Add(new CodeTypeReference("Dictionary",
new CodeTypeReference[] {
new CodeTypeReference("TKey"),
new CodeTypeReference("TValue"),
}));
//<Snippet2>
//<Snippet10>
CodeTypeParameter kType = new CodeTypeParameter("TKey");
//</Snippet2>
//<Snippet3>
kType.HasConstructorConstraint = true;
//</Snippet3>
//<Snippet4>
kType.Constraints.Add(new CodeTypeReference(typeof(IComparable)));
//</Snippet4>
//<Snippet5>
kType.CustomAttributes.Add(new CodeAttributeDeclaration(
"System.ComponentModel.DescriptionAttribute",
new CodeAttributeArgument(new CodePrimitiveExpression("KeyType"))));
//</Snippet5>
CodeTypeReference iComparableT = new CodeTypeReference("IComparable");
iComparableT.TypeArguments.Add(new CodeTypeReference(kType));
kType.Constraints.Add(iComparableT);
CodeTypeParameter vType = new CodeTypeParameter("TValue");
vType.Constraints.Add(new CodeTypeReference(typeof(IList <System.String>)));
vType.CustomAttributes.Add(new CodeAttributeDeclaration(
"System.ComponentModel.DescriptionAttribute",
new CodeAttributeArgument(new CodePrimitiveExpression("ValueType"))));
class1.TypeParameters.Add(kType);
class1.TypeParameters.Add(vType);
//</Snippet10>
ns.Types.Add(class1);
//<Snippet6>
// Declare a generic method.
CodeMemberMethod printMethod = new CodeMemberMethod();
CodeTypeParameter sType = new CodeTypeParameter("S");
sType.HasConstructorConstraint = true;
CodeTypeParameter tType = new CodeTypeParameter("T");
sType.HasConstructorConstraint = true;
printMethod.Name = "Print";
printMethod.TypeParameters.Add(sType);
printMethod.TypeParameters.Add(tType);
//</Snippet6>
//<Snippet7>
printMethod.Statements.Add(ConsoleWriteLineStatement(
new CodeDefaultValueExpression(new CodeTypeReference("T"))));
printMethod.Statements.Add(ConsoleWriteLineStatement(
new CodeDefaultValueExpression(new CodeTypeReference("S"))));
//</Snippet7>
printMethod.Attributes = MemberAttributes.Public;
class1.Members.Add(printMethod);
CodeTypeDeclaration class2 = new CodeTypeDeclaration();
class2.Name = "Demo";
CodeEntryPointMethod methodMain = new CodeEntryPointMethod();
CodeTypeReference myClass = new CodeTypeReference(
"MyDictionary",
new CodeTypeReference[] {
new CodeTypeReference(typeof(int)),
new CodeTypeReference("List",
new CodeTypeReference[]
{ new CodeTypeReference("System.String") })
});
methodMain.Statements.Add(
new CodeVariableDeclarationStatement(myClass,
"dict",
new CodeObjectCreateExpression(myClass)));
methodMain.Statements.Add(ConsoleWriteLineStatement(
new CodePropertyReferenceExpression(
new CodeVariableReferenceExpression("dict"),
"Count")));
//<Snippet9>
methodMain.Statements.Add(new CodeExpressionStatement(
new CodeMethodInvokeExpression(
new CodeMethodReferenceExpression(
new CodeVariableReferenceExpression("dict"),
"Print",
new CodeTypeReference[] {
new CodeTypeReference("System.Decimal"),
new CodeTypeReference("System.Int32"),
}),
new CodeExpression[0])));
//</Snippet9>
string dictionaryTypeName = typeof(System.Collections.Generic.Dictionary <int,
System.Collections.Generic.List <string> >[]).FullName;
CodeTypeReference dictionaryType = new CodeTypeReference(dictionaryTypeName);
methodMain.Statements.Add(
new CodeVariableDeclarationStatement(dictionaryType, "dict2",
new CodeArrayCreateExpression(dictionaryType, new CodeExpression[1] {
new CodePrimitiveExpression(null)
})));
methodMain.Statements.Add(ConsoleWriteLineStatement(
new CodePropertyReferenceExpression(
new CodeVariableReferenceExpression("dict2"),
"Length")));
class2.Members.Add(methodMain);
ns.Types.Add(class2);
}
public CodeTypeReference(CodeTypeParameter typeParameter)
{
throw new NotImplementedException();
}
void OutputTypeParameterConstraints (CodeTypeParameter parameter)
{
int constraint_count = parameter.Constraints.Count +
(parameter.HasConstructorConstraint ? 1 : 0);
if (constraint_count == 0)
return;
Output.Write (" As ");
if (constraint_count > 1)
Output.Write (" {");
for (int i = 0; i < parameter.Constraints.Count; i++) {
if (i > 0)
Output.Write (", ");
OutputType (parameter.Constraints [i]);
}
if (parameter.HasConstructorConstraint) {
if (constraint_count > 1)
Output.Write (", ");
Output.Write ("New");
}
if (constraint_count > 1)
Output.Write ("}");
}
public int Add(CodeTypeParameter value) => List.Add(value);
public static CodeTypeParameterCollection GenericTypeParameters(Type t)
{
if (!t.IsGenericType) return null;
var p = new CodeTypeParameterCollection();
foreach (var genericParameter in t.GetGenericTypeDefinition().GetGenericArguments())
{
var param = new CodeTypeParameter(genericParameter.Name);
if ((genericParameter.GenericParameterAttributes &
GenericParameterAttributes.ReferenceTypeConstraint) != GenericParameterAttributes.None)
{
param.Constraints.Add(" class");
}
if ((genericParameter.GenericParameterAttributes &
GenericParameterAttributes.NotNullableValueTypeConstraint) != GenericParameterAttributes.None)
{
param.Constraints.Add(" struct");
}
var constraints = genericParameter.GetGenericParameterConstraints();
foreach (var constraintType in constraints)
{
param.Constraints.Add(
new CodeTypeReference(TypeUtils.GetParameterizedTemplateName(constraintType, false,
x => true)));
}
if ((genericParameter.GenericParameterAttributes &
GenericParameterAttributes.DefaultConstructorConstraint) != GenericParameterAttributes.None)
{
param.HasConstructorConstraint = true;
}
p.Add(param);
}
return p;
}
public void Remove(CodeTypeParameter value)
{
}
public bool Contains(CodeTypeParameter value)
{
return(default(bool));
}
public bool Contains(CodeTypeParameter value) => List.Contains(value);
public CodeTypeReference(CodeTypeParameter typeParameter)
{
}
public void Insert(int index, CodeTypeParameter value)
{
throw new NotImplementedException();
}
public bool Contains(CodeTypeParameter value)
{
return(List.Contains(value));
}
private static void PopulateGenericParameters(IGenericParameterProvider publicType, CodeTypeParameterCollection parameters)
{
foreach (var parameter in publicType.GenericParameters)
{
if (parameter.HasCustomAttributes)
throw new NotImplementedException("Attributes on type parameters is not supported. And weird");
// A little hacky. Means we get "in" and "out" prefixed on any constraints, but it's either that
// or add it as a custom attribute, which looks even weirder
var name = parameter.Name;
if (parameter.IsCovariant)
name = "out " + name;
if (parameter.IsContravariant)
name = "in " + name;
var typeParameter = new CodeTypeParameter(name)
{
HasConstructorConstraint =
parameter.HasDefaultConstructorConstraint && !parameter.HasNotNullableValueTypeConstraint
};
if (parameter.HasNotNullableValueTypeConstraint)
typeParameter.Constraints.Add(" struct"); // Extra space is a hack!
if (parameter.HasReferenceTypeConstraint)
typeParameter.Constraints.Add(" class");
foreach (var constraint in parameter.Constraints.Where(t => t.FullName != "System.ValueType"))
{
typeParameter.Constraints.Add(CreateCodeTypeReference(constraint.GetElementType()));
}
parameters.Add(typeParameter);
}
}
public void Insert(int index, CodeTypeParameter value)
{
List.Insert(index, value);
}
public CodeTypeReference(CodeTypeParameter typeParameter) :
this((typeParameter == null) ? (string)null : typeParameter.Name)
{
_referenceOptions = CodeTypeReferenceOptions.GenericTypeParameter;
}
public CodeTypeReference(CodeTypeParameter typeParameter)
{
}
public int Add(CodeTypeParameter value)
{
return(default(int));
}
public int IndexOf(CodeTypeParameter value) => List.IndexOf(value);
public int IndexOf(CodeTypeParameter value)
{
return(default(int));
}
void VisitCodeTypeParameter(CodeTypeParameter parameter)
{
WriteLine("VisitCodeTypeParameter: " + parameter.Name);
}
private void OutputTypeParameterConstraints(CodeTypeParameter typeParameter)
{
CodeTypeReferenceCollection constraints = typeParameter.Constraints;
int count = constraints.Count;
if (typeParameter.HasConstructorConstraint)
{
count++;
}
if (count != 0)
{
base.Output.Write(" As ");
if (count > 1)
{
base.Output.Write(" {");
}
bool flag = true;
foreach (CodeTypeReference reference in constraints)
{
if (flag)
{
flag = false;
}
else
{
base.Output.Write(", ");
}
base.Output.Write(this.GetTypeOutput(reference));
}
if (typeParameter.HasConstructorConstraint)
{
if (!flag)
{
base.Output.Write(", ");
}
base.Output.Write("New");
}
if (count > 1)
{
base.Output.Write('}');
}
}
}
public CodeTypeReference(CodeTypeParameter typeParameter):
this( (typeParameter == null) ? (string)null : typeParameter.Name) {
referenceOptions = CodeTypeReferenceOptions.GenericTypeParameter;
}
public CodeTypeReference(CodeTypeParameter typeParameter) :
this(typeParameter.Name)
{
this.referenceOptions = CodeTypeReferenceOptions.GenericTypeParameter;
}
static void ConvertRequestToGeneric(SdkMessagePair messagePair, CodeTypeDeclaration requestClass, CodeMemberProperty requestField)
{
var parameter = new CodeTypeParameter(requestField.Type.BaseType)
{
HasConstructorConstraint = true
};
parameter.Constraints.Add(new CodeTypeReference(EntityClassBaseType));
requestClass.TypeParameters.Add(parameter);
requestClass.Members.Add(Constructor(new CodeExpression[] {New(requestField.Type, new CodeExpression[0])}));
var constructor = Constructor(Param(requestField.Type, "target"), new CodeStatement[] {AssignProp(requestField.Name, VarRef("target"))});
constructor.Statements.Add(AssignProp(RequestNamePropertyName, new CodePrimitiveExpression(messagePair.Request.Name)));
requestClass.Members.Add(constructor);
}
public void Constructor4_Deny_Unrestricted ()
{
CodeTypeParameter parameter = new CodeTypeParameter ("System.Int32");
CodeTypeReference ctr = new CodeTypeReference (parameter);
Assert.IsNull (ctr.ArrayElementType, "ArrayElementType");
Assert.AreEqual ("System.Int32", ctr.BaseType, "BaseType");
Assert.AreEqual (0, ctr.ArrayRank, "ArrayRank");
ctr.ArrayElementType = new CodeTypeReference ();
ctr.BaseType = String.Empty;
ctr.ArrayRank = 1;
Assert.AreEqual (CodeTypeReferenceOptions.GenericTypeParameter, ctr.Options, "Options");
ctr.Options = CodeTypeReferenceOptions.GlobalReference;
Assert.AreEqual (0, ctr.TypeArguments.Count, "TypeArguments");
}
private void AddCreateNewElementMethod(CodeTypeDeclaration declaration)
{
CodeMemberMethod method = new CodeMemberMethod();
method.Name = "CreateNewElement";
CodeTypeParameter genericParameter = new CodeTypeParameter("T");
genericParameter.HasConstructorConstraint = false;
method.TypeParameters.Add(genericParameter);
method.ReturnType = new CodeTypeReference(genericParameter);
method.ImplementationTypes.Add(typeof(IXmlDataProviderHelper));
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(IData), "data"));
CodeParameterDeclarationExpression parameter = new CodeParameterDeclarationExpression(typeof(XElement), "newElement");
parameter.Direction = FieldDirection.Out;
method.Parameters.Add(parameter);
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "elementName"));
method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(string), "providerName"));
method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
method.Statements.Add(new CodeVariableDeclarationStatement(
InterfaceName,
"xmlData"));
method.Statements.Add(new CodeTryCatchFinallyStatement(
new CodeStatement[] {
new CodeAssignStatement(
new CodeVariableReferenceExpression("xmlData"),
new CodeCastExpression(
InterfaceName,
new CodeVariableReferenceExpression("data"))
)
},
new CodeCatchClause[] {
new CodeCatchClause("e", new CodeTypeReference(typeof(Exception)), new CodeStatement[] {
new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(
new CodeTypeReference(typeof(ArgumentException)),
new CodeExpression[] {
new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(string)),
"Format",
new CodeExpression[] {
new CodePrimitiveExpression("The type ({0}) of the given data parameter does not match the type {1}"),
new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression("data"),
"GetType",
new CodeExpression[] {}
),
new CodeTypeOfExpression(InterfaceName)
}
),
new CodeVariableReferenceExpression("e")
}
)
)
})
}
));
const string newElementVariableName = "newElement";
method.Statements.Add(new CodeAssignStatement(
new CodeVariableReferenceExpression(newElementVariableName),
new CodeObjectCreateExpression(
typeof(XElement),
new CodeVariableReferenceExpression("elementName")
)
));
foreach (DataFieldDescriptor field in _dataTypeDescriptor.Fields)
{
method.Statements.Add(new CodeCommentStatement(string.Format("Interface Property {0}", field.Name)));
CodeMethodInvokeExpression codeExpression = new CodeMethodInvokeExpression(
new CodeVariableReferenceExpression(newElementVariableName),
"Add",
new CodeExpression[] {
new CodeObjectCreateExpression(
typeof(XAttribute),
new CodeExpression[] {
new CodePrimitiveExpression(field.Name),
new CodePropertyReferenceExpression(
new CodeVariableReferenceExpression("xmlData"),
field.Name
)
}
)
}
);
if ((field.InstanceType.IsGenericType) &&
(field.InstanceType.GetGenericTypeDefinition() == typeof(Nullable<>)))
{
method.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodePropertyReferenceExpression(
new CodePropertyReferenceExpression(
new CodeVariableReferenceExpression("xmlData"),
field.Name
),
"HasValue"
),
CodeBinaryOperatorType.IdentityEquality,
new CodePrimitiveExpression(true)
),
new CodeStatement[] {
new CodeExpressionStatement(
codeExpression
)
}
));
}
else if (field.InstanceType == typeof(string))
{
method.Statements.Add(
new CodeConditionStatement(
new CodeBinaryOperatorExpression(
new CodePropertyReferenceExpression(
new CodeVariableReferenceExpression("xmlData"),
field.Name
),
CodeBinaryOperatorType.IdentityInequality,
new CodePrimitiveExpression(null)
),
new CodeStatement[] {
new CodeExpressionStatement(
codeExpression
)
}
));
}
else
{
method.Statements.Add(codeExpression);
}
}
method.Statements.Add(new CodeCommentStatement("Done with properties"));
method.Statements.Add(new CodeVariableDeclarationStatement(
typeof(IData),
"newData",
new CodeObjectCreateExpression(
_wrapperClassName,
new CodeExpression[] {
new CodeVariableReferenceExpression("newElement"),
new CodeObjectCreateExpression(
typeof(DataSourceId),
new CodeExpression[] {
new CodeObjectCreateExpression(
_dataIdClassName,
new CodeVariableReferenceExpression("newElement")
),
new CodeVariableReferenceExpression("providerName"),
new CodeTypeOfExpression(InterfaceName)
}
)
}
)
));
method.Statements.Add(new CodeMethodReturnStatement(
new CodeCastExpression(
new CodeTypeReference(genericParameter),
new CodeVariableReferenceExpression("newData")
)
));
declaration.Members.Add(method);
}
public int Add(CodeTypeParameter value)
{
return(List.Add(value));
}
private void ValidateTypeParameter(CodeTypeParameter e) {
ValidateIdentifier(e, "Name", e.Name);
ValidateTypeReferences(e.Constraints);
ValidateAttributes(e.CustomAttributes);
}
public int IndexOf(CodeTypeParameter value)
{
return(List.IndexOf(value));
}
public void Insert ()
{
CodeTypeParameter tp1 = new CodeTypeParameter ();
CodeTypeParameter tp2 = new CodeTypeParameter ();
CodeTypeParameterCollection coll = new CodeTypeParameterCollection ();
coll.Add (tp1);
Assert.AreEqual (1, coll.Count, "#1");
Assert.AreEqual (0, coll.IndexOf (tp1), "#2");
coll.Insert (0, tp2);
Assert.AreEqual (2, coll.Count, "#3");
Assert.AreEqual (1, coll.IndexOf (tp1), "#4");
Assert.AreEqual (0, coll.IndexOf (tp2), "#5");
}
public void Remove(CodeTypeParameter value)
{
List.Remove(value);
}
public void AddRange ()
{
CodeTypeParameter tp1 = new CodeTypeParameter ();
CodeTypeParameter tp2 = new CodeTypeParameter ();
CodeTypeParameter tp3 = new CodeTypeParameter ();
CodeTypeParameterCollection coll1 = new CodeTypeParameterCollection ();
coll1.Add (tp1);
coll1.Add (tp2);
CodeTypeParameterCollection coll2 = new CodeTypeParameterCollection ();
coll2.Add (tp3);
coll2.AddRange (coll1);
Assert.AreEqual (3, coll2.Count, "#1");
Assert.AreEqual (1, coll2.IndexOf (tp1), "#2");
Assert.AreEqual (2, coll2.IndexOf (tp2), "#3");
Assert.AreEqual (0, coll2.IndexOf (tp3), "#4");
CodeTypeParameterCollection coll3 = new CodeTypeParameterCollection ();
coll3.Add (tp3);
coll3.AddRange (new CodeTypeParameter[] { tp1, tp2 });
Assert.AreEqual (3, coll2.Count, "#5");
Assert.AreEqual (1, coll2.IndexOf (tp1), "#6");
Assert.AreEqual (2, coll2.IndexOf (tp2), "#7");
Assert.AreEqual (0, coll2.IndexOf (tp3), "#8");
}
public CodeTypeReference( CodeTypeParameter typeParameter ) :
this (typeParameter.Name)
{
this.referenceOptions = CodeTypeReferenceOptions.GenericTypeParameter;
}
public bool Contains(CodeTypeParameter value)
{
throw new NotImplementedException();
}
