C# CodeDom.CodeTypeParameter类代码示例

        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 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 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 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 void Constructor1_NullItem ()
		{
			CodeTypeParameter[] typeParams = new CodeTypeParameter[] { 
				new CodeTypeParameter (), null };

			CodeTypeParameterCollection coll = new CodeTypeParameterCollection (
				typeParams);
		}

 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_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 void AddRange (CodeTypeParameter[] value)
		{
			if (value == null) {
				throw new ArgumentNullException ("value");
			}

			for (int i = 0; i < value.Length; i++) {
				Add (value[i]);
			}
		}

        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 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;
        }