c#创建类属性_c# 动态创建类及属性 - CSDN
  • 1 class Person 2 { 3 private string name; 4 private string age; 5 private string job; 6 7 public Person(string name,string age,string job) 8 ...
     1 class Person
     2     {
     3         private string name;
     4         private string age;
     5         private string job;
     6 
     7         public Person(string name,string age,string job)
     8         {
     9             this.name = name;
    10             this.age = age;
    11             this.job = job;
    12         }
    13 
    14         //因为有get方法,所以必须要有返回类型
    15         public string Name
    16         {
    17             get { return this.name; }
    18             set { this.name = value; }//赋值的来源是系统级别的value变量,系统维护的
    19         }
    20 
    21         public string Age
    22         {
    23             get { return this.age; }
    24             set { this.age = value; }
    25         }
    26 
    27         public string Job
    28         {
    29             get { return this.job; }
    30             set { this.job = value; }
    31         }
    32     }
    View Code

     

    展开全文
  • C#类动态添加属性

    2015-09-16 14:59:45
    动态实现 using System; using System.Collections.Generic; using System.Reflection.Emit; using System.Reflection; using System.Threading; namespace CopyMapFile { /**//// /// 帮助器,可以...

    动态类实现

    using System;  
    using System.Collections.Generic;  
    using System.Reflection.Emit;  
    using System.Reflection;  
    using System.Threading;  
      
    namespace CopyMapFile  
    {  
    /**//// <summary>  
    /// 类帮助器,可以动态对类,类成员进行控制(添加,删除),目前只支持属性控制。  
    /// 注意,属性以外的其它成员会被清空,功能还有待完善,使其不影响其它成员。  
    /// </summary>  
        public class ClassHelper  
        {  
            #region 公有方法  
            /**//// <summary>  
            /// 防止实例化。  
            /// </summary>  
            private ClassHelper() { }  
      
            /**//// <summary>  
            /// 根据类的类型型创建类实例。  
            /// </summary>  
            /// <param name="t">将要创建的类型。</param>  
            /// <returns>返回创建的类实例。</returns>  
            public static object CreateInstance(Type t)  
            {  
                return Activator.CreateInstance(t);  
            }  
      
            /**//// <summary>  
            /// 根据类的名称,属性列表创建型实例。  
            /// </summary>  
            /// <param name="className">将要创建的类的名称。</param>  
            /// <param name="lcpi">将要创建的类的属性列表。</param>  
            /// <returns>返回创建的类实例</returns>  
            public static object CreateInstance(string className, List<CustPropertyInfo> lcpi)  
            {  
                Type t = BuildType(className);  
                t = AddProperty(t, lcpi);  
                return Activator.CreateInstance(t);  
            }  
      
            /**//// <summary>  
            /// 根据属性列表创建类的实例,默认类名为DefaultClass,由于生成的类不是强类型,所以类名可以忽略。  
            /// </summary>  
            /// <param name="lcpi">将要创建的类的属性列表</param>  
            /// <returns>返回创建的类的实例。</returns>  
            public static object CreateInstance(List<CustPropertyInfo> lcpi)  
            {  
                return CreateInstance("DefaultClass", lcpi);  
            }  
      
            /**//// <summary>  
            /// 根据类的实例设置类的属性。  
            /// </summary>  
            /// <param name="classInstance">将要设置的类的实例。</param>  
            /// <param name="propertyName">将要设置属性名。</param>  
            /// <param name="propertSetValue">将要设置属性值。</param>  
            public static void SetPropertyValue(object classInstance, string propertyName, object propertSetValue)  
            {  
                classInstance.GetType().InvokeMember(propertyName, BindingFlags.SetProperty,  
                                              null, classInstance, new object[] { Convert.ChangeType(propertSetValue, propertSetValue.GetType()) });  
            }  
      
            /**//// <summary>  
            /// 根据类的实例获取类的属性。  
            /// </summary>  
            /// <param name="classInstance">将要获取的类的实例</param>  
            /// <param name="propertyName">将要设置的属性名。</param>  
            /// <returns>返回获取的类的属性。</returns>  
            public static object GetPropertyValue(object classInstance, string propertyName)  
            {  
                return classInstance.GetType().InvokeMember(propertyName, BindingFlags.GetProperty,  
                                                              null, classInstance, new object[] { });  
            }  
      
            /**//// <summary>  
            /// 创建一个没有成员的类型的实例,类名为"DefaultClass"。  
            /// </summary>  
            /// <returns>返回创建的类型的实例。</returns>  
            public static Type BuildType()  
            {  
                return BuildType("DefaultClass");  
            }  
      
            /**//// <summary>  
            /// 根据类名创建一个没有成员的类型的实例。  
            /// </summary>  
            /// <param name="className">将要创建的类型的实例的类名。</param>  
            /// <returns>返回创建的类型的实例。</returns>  
            public static Type BuildType(string className)  
            {  
      
                AppDomain myDomain = Thread.GetDomain();  
                AssemblyName myAsmName = new AssemblyName();  
                myAsmName.Name = "MyDynamicAssembly";  
      
                //创建一个永久程序集,设置为AssemblyBuilderAccess.RunAndSave。  
                AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(myAsmName,  
                                                                AssemblyBuilderAccess.RunAndSave);  
      
                //创建一个永久单模程序块。  
                ModuleBuilder myModBuilder =  
                    myAsmBuilder.DefineDynamicModule(myAsmName.Name, myAsmName.Name + ".dll");  
                //创建TypeBuilder。  
                TypeBuilder myTypeBuilder = myModBuilder.DefineType(className,  
                                                                TypeAttributes.Public);  
      
                //创建类型。  
                Type retval = myTypeBuilder.CreateType();  
      
                //保存程序集,以便可以被Ildasm.exe解析,或被测试程序引用。  
                //myAsmBuilder.Save(myAsmName.Name + ".dll");  
                return retval;  
            }  
      
            /**//// <summary>  
            /// 添加属性到类型的实例,注意:该操作会将其它成员清除掉,其功能有待完善。  
            /// </summary>  
            /// <param name="classType">指定类型的实例。</param>  
            /// <param name="lcpi">表示属性的一个列表。</param>  
            /// <returns>返回处理过的类型的实例。</returns>  
            public static Type AddProperty(Type classType, List<CustPropertyInfo> lcpi)  
            {  
                //合并先前的属性,以便一起在下一步进行处理。  
                MergeProperty(classType, lcpi);  
                //把属性加入到Type。  
                return AddPropertyToType(classType, lcpi);  
            }  
      
            /**//// <summary>  
            /// 添加属性到类型的实例,注意:该操作会将其它成员清除掉,其功能有待完善。  
            /// </summary>  
            /// <param name="classType">指定类型的实例。</param>  
            /// <param name="cpi">表示一个属性。</param>  
            /// <returns>返回处理过的类型的实例。</returns>  
            public static Type AddProperty(Type classType, CustPropertyInfo cpi)  
            {  
                List<CustPropertyInfo> lcpi = new List<CustPropertyInfo>();  
                lcpi.Add(cpi);  
                //合并先前的属性,以便一起在下一步进行处理。  
                MergeProperty(classType, lcpi);  
                //把属性加入到Type。  
                return AddPropertyToType(classType, lcpi);  
            }  
      
            /**//// <summary>  
            /// 从类型的实例中移除属性,注意:该操作会将其它成员清除掉,其功能有待完善。  
            /// </summary>  
            /// <param name="classType">指定类型的实例。</param>  
            /// <param name="propertyName">要移除的属性。</param>  
            /// <returns>返回处理过的类型的实例。</returns>  
            public static Type DeleteProperty(Type classType, string propertyName)  
            {  
                List<string> ls = new List<string>();  
                ls.Add(propertyName);  
      
                //合并先前的属性,以便一起在下一步进行处理。  
                List<CustPropertyInfo> lcpi = SeparateProperty(classType, ls);  
                //把属性加入到Type。  
                return AddPropertyToType(classType, lcpi);  
            }  
      
            /**//// <summary>  
            /// 从类型的实例中移除属性,注意:该操作会将其它成员清除掉,其功能有待完善。  
            /// </summary>  
            /// <param name="classType">指定类型的实例。</param>  
            /// <param name="ls">要移除的属性列表。</param>  
            /// <returns>返回处理过的类型的实例。</returns>  
            public static Type DeleteProperty(Type classType, List<string> ls)  
            {  
                //合并先前的属性,以便一起在下一步进行处理。  
                List<CustPropertyInfo> lcpi = SeparateProperty(classType, ls);  
                //把属性加入到Type。  
                return AddPropertyToType(classType, lcpi);  
            }  
            #endregion  
     
            #region 私有方法  
            /**//// <summary>  
            /// 把类型的实例t和lcpi参数里的属性进行合并。  
            /// </summary>  
            /// <param name="t">实例t</param>  
            /// <param name="lcpi">里面包含属性列表的信息。</param>  
            private static void MergeProperty(Type t, List<CustPropertyInfo> lcpi)  
            {  
                foreach (PropertyInfo pi in t.GetProperties())  
                {  
                    CustPropertyInfo cpi = new CustPropertyInfo(pi.PropertyType.FullName, pi.Name);  
                    lcpi.Add(cpi);  
                }  
            }  
      
            /**//// <summary>  
            /// 从类型的实例t的属性移除属性列表lcpi,返回的新属性列表在lcpi中。  
            /// </summary>  
            /// <param name="t">类型的实例t。</param>  
            /// <param name="ls">要移除的属性列表。</param>  
            private static List<CustPropertyInfo> SeparateProperty(Type t, List<string> ls)  
            {  
                List<CustPropertyInfo> ret = new List<CustPropertyInfo>();  
                foreach (PropertyInfo pi in t.GetProperties())  
                {  
                    foreach (string s in ls)  
                    {  
                        if (pi.Name != s)  
                        {  
                            CustPropertyInfo cpi = new CustPropertyInfo(pi.PropertyType.FullName, pi.Name);  
                            ret.Add(cpi);  
                        }  
                    }  
                }  
      
                return ret;  
            }  
      
            /**//// <summary>  
            /// 把lcpi参数里的属性加入到myTypeBuilder中。注意:该操作会将其它成员清除掉,其功能有待完善。  
            /// </summary>  
            /// <param name="myTypeBuilder">类型构造器的实例。</param>  
            /// <param name="lcpi">里面包含属性列表的信息。</param>  
            private static void AddPropertyToTypeBuilder(TypeBuilder myTypeBuilder, List<CustPropertyInfo> lcpi)  
            {  
                PropertyBuilder custNamePropBldr;  
                MethodBuilder custNameGetPropMthdBldr;  
                MethodBuilder custNameSetPropMthdBldr;  
                MethodAttributes getSetAttr;  
                ILGenerator custNameGetIL;  
                ILGenerator custNameSetIL;  
      
                // 属性Set和Get方法要一个专门的属性。这里设置为Public。  
                getSetAttr =  
                    MethodAttributes.Public | MethodAttributes.SpecialName |  
                        MethodAttributes.HideBySig;  
      
                // 添加属性到myTypeBuilder。  
                foreach (CustPropertyInfo cpi in lcpi)  
                {  
                    //定义字段。  
                    FieldBuilder customerNameBldr = myTypeBuilder.DefineField(cpi.FieldName,  
                                                                              Type.GetType(cpi.Type),  
                                                                              FieldAttributes.Private);  
                    customerNameBldr.SetConstant("11111111");  
                    //定义属性。  
                    //最后一个参数为null,因为属性没有参数。  
                    custNamePropBldr = myTypeBuilder.DefineProperty(cpi.PropertyName,  
                                                                     PropertyAttributes.HasDefault,  
                                                                     Type.GetType(cpi.Type),  
                                                                     null);  
      
                    custNamePropBldr.SetConstant("111111111");  
                    //定义Get方法。  
                    custNameGetPropMthdBldr =  
                        myTypeBuilder.DefineMethod(cpi.GetPropertyMethodName,  
                                                   getSetAttr,  
                                                   Type.GetType(cpi.Type),  
                                                   Type.EmptyTypes);  
      
                    custNameGetIL = custNameGetPropMthdBldr.GetILGenerator();  
      
                    try  
                    {  
                        custNameGetIL.Emit(OpCodes.Ldarg_0);  
                        //custNameGetIL.Emit(OpCodes.Ldfld, customerNameBldr);  
                        custNameGetIL.Emit(OpCodes.Ldfld, customerNameBldr);  
                        custNameGetIL.Emit(OpCodes.Ret);  
                    }  
                    catch (Exception ex)  
                    {  
      
                         
                    }  
      
                    //定义Set方法。  
                    custNameSetPropMthdBldr =  
                        myTypeBuilder.DefineMethod(cpi.SetPropertyMethodName,  
                                                   getSetAttr,  
                                                   null,  
                                                   new Type[] { Type.GetType(cpi.Type) });  
      
                    custNameSetIL = custNameSetPropMthdBldr.GetILGenerator();  
      
                    custNameSetIL.Emit(OpCodes.Ldarg_0);  
                    custNameSetIL.Emit(OpCodes.Ldarg_1);  
                    custNameSetIL.Emit(OpCodes.Stfld, customerNameBldr);  
                    custNameSetIL.Emit(OpCodes.Ret);  
                    //custNamePropBldr.SetConstant("ceshi");  
                    //把创建的两个方法(Get,Set)加入到PropertyBuilder中。  
                    custNamePropBldr.SetGetMethod(custNameGetPropMthdBldr);  
                    custNamePropBldr.SetSetMethod(custNameSetPropMthdBldr);  
                }  
            }  
      
            /**//// <summary>  
            /// 把属性加入到类型的实例。  
            /// </summary>  
            /// <param name="classType">类型的实例。</param>  
            /// <param name="lcpi">要加入的属性列表。</param>  
            /// <returns>返回处理过的类型的实例。</returns>  
            public static Type AddPropertyToType(Type classType, List<CustPropertyInfo> lcpi)  
            {  
                AppDomain myDomain = Thread.GetDomain();  
                AssemblyName myAsmName = new AssemblyName();  
                myAsmName.Name = "MyDynamicAssembly";  
      
                //创建一个永久程序集,设置为AssemblyBuilderAccess.RunAndSave。  
                AssemblyBuilder myAsmBuilder = myDomain.DefineDynamicAssembly(myAsmName,  
                                                                AssemblyBuilderAccess.RunAndSave);  
      
                //创建一个永久单模程序块。  
                ModuleBuilder myModBuilder =  
                    myAsmBuilder.DefineDynamicModule(myAsmName.Name, myAsmName.Name + ".dll");  
                //创建TypeBuilder。  
                TypeBuilder myTypeBuilder = myModBuilder.DefineType(classType.FullName,  
                                                                TypeAttributes.Public);  
      
                //把lcpi中定义的属性加入到TypeBuilder。将清空其它的成员。其功能有待扩展,使其不影响其它成员。  
                AddPropertyToTypeBuilder(myTypeBuilder, lcpi);  
      
                //创建类型。  
                Type retval = myTypeBuilder.CreateType();  
      
                //保存程序集,以便可以被Ildasm.exe解析,或被测试程序引用。  
                //myAsmBuilder.Save(myAsmName.Name + ".dll");  
                return retval;  
            }  
            #endregion  
     
            #region 辅助类  
            /**//// <summary>  
            /// 自定义的属性信息类型。  
            /// </summary>  
            public class CustPropertyInfo  
            {  
                private string propertyName;  
                private string type;  
      
                /**//// <summary>  
                /// 空构造。  
                /// </summary>  
                public CustPropertyInfo() { }  
      
                /**//// <summary>  
                /// 根据属性类型名称,属性名称构造实例。  
                /// </summary>  
                /// <param name="type">属性类型名称。</param>  
                /// <param name="propertyName">属性名称。</param>  
                public CustPropertyInfo(string type, string propertyName)  
                {  
                    this.type = type;  
                    this.propertyName = propertyName;  
                }  
      
                /**//// <summary>  
                /// 获取或设置属性类型名称。  
                /// </summary>  
                public string Type  
                {  
                    get { return type; }  
                    set { type = value; }  
                }  
      
                /**//// <summary>  
                /// 获取或设置属性名称。  
                /// </summary>  
                public string PropertyName  
                {  
                    get { return propertyName; }  
                    set { propertyName = value; }  
                }  
      
                /**//// <summary>  
                /// 获取属性字段名称。  
                /// </summary>  
                public string FieldName  
                {  
                    get   
                    {  
                        if (propertyName.Length < 1)  
                            return "";  
                        return propertyName.Substring(0, 1).ToLower() + propertyName.Substring(1);   
                    }  
                }  
      
                /**//// <summary>  
                /// 获取属性在IL中的Set方法名。  
                /// </summary>  
                public string SetPropertyMethodName  
                {  
                    get { return "set_" + PropertyName; }  
                }  
      
                /**//// <summary>  
                ///  获取属性在IL中的Get方法名。  
                /// </summary>  
                public string GetPropertyMethodName  
                {  
                    get { return "get_" + PropertyName; }  
                }  
            }  
            #endregion  
        }  
    }  
    


    展开全文
  • 先有,再创建对象,决定了对象将要拥有的属性和行为;对象是具体实例,创建对象的模具,是抽象的。是一种数据类型,用户自定义的数据类型 this,当前的对象,base,对象是引用类型; base()调用父类的成员...

    1、封装属性的快捷键:ctrl+R+E    :弹出封装好的属性

    2、自动属性快捷键:输入prop+tab+tab  

    3、先有类,再创建对象,类决定了对象将要拥有的属性和行为;对象是具体实例,类是创建对象的模具,是抽象的。类是一种数据类型,用户自定义的数据类型

    4、this,当前类的对象,base,对象是引用类型;

    5、base()调用父类的成员:  base.ToStr();  //调用父类的成员方法    this代表当前对象

    6、对于自动属性的属性,我们通过构造函数来保护

            public int MyProperty { get; set; }
            public Person(int myProperty)
            {
                this.MyProperty =myProperty;
            }

    7、子类继承抽象父类,必须重写所有的父类抽象方法;快速实现:出现小蓝框:Alt+Shift+F10

    8、抽象方法只存在抽象类中;抽象类中可以有非抽象方法。


    展开全文
  • C# 动态创建一个

    2017-07-09 23:57:08
    C# 在运行时动态的创建类型是通过动态生成C#源代码,然后通过编译器编译成程序集的方式实现动态创建类型的。 主要功能代码如下: public static Assembly NewAssembly() {  //创建编译器实例。  ...

    C# 在运行时动态的创建类型是通过动态生成C#源代码,然后通过编译器编译成程序集的方式实现动态创建类型的。

    主要功能代码如下:

    public static Assembly NewAssembly()

    {

      //创建编译器实例。 

      provider = new CSharpCodeProvider();

      //设置编译参数。 

      cp = new CompilerParameters();

      cp.GenerateExecutable = false;

      cp.GenerateInMemory = true;

      // Generate an executable instead of

      // a class library.

      //cp.GenerateExecutable = true;

      // Set the assembly file name to generate.

      cp.OutputAssembly = "c:\\1.dll";

      // Generate debug information.

      cp.IncludeDebugInformation = true;

      // Save the assembly as a physical file.

      cp.GenerateInMemory = false;

      // Set the level at which the compiler

      // should start displaying warnings.

      cp.WarningLevel = 3;

      // Set whether to treat all warnings as errors.

      cp.TreatWarningsAsErrors = false;

      // Set compiler argument to optimize output.

      cp.CompilerOptions = "/optimize";

      cp.ReferencedAssemblies.Add("System.dll");

      //cp.ReferencedAssemblies.Add("System.Core.dll");

      cp.ReferencedAssemblies.Add("System.Data.dll");

      //cp.ReferencedAssemblies.Add("System.Data.DataSetExtensions.dll");

      cp.ReferencedAssemblies.Add("System.Deployment.dll");

      cp.ReferencedAssemblies.Add("System.Design.dll");

      cp.ReferencedAssemblies.Add("System.Drawing.dll");

      cp.ReferencedAssemblies.Add("System.Windows.Forms.dll");

      //创建动态代码。 

      StringBuilder classSource = new StringBuilder();

      classSource.Append("using System;using System.Windows.Forms;\npublic  class  DynamicClass: UserControl \n");

      classSource.Append("{\n");

      classSource.Append("public DynamicClass()\n{\nInitializeComponent();\nConsole.WriteLine(\"hello\");}\n");

      classSource.Append( "private System.ComponentModel.IContainer components = null;\nprotected override void Dispose(bool disposing)\n{\n");

      classSource.Append( "if (disposing && (components != null)){components.Dispose();}base.Dispose(disposing);\n}\n");

      classSource.Append( "private void InitializeComponent(){\nthis.SuspendLayout();this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 12F);");

      classSource.Append( "this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;this.Name = \"DynamicClass\";this.Size = new System.Drawing.Size(112, 74);this.ResumeLayout(false);\n}");

      //创建属性。 

      /*************************在这里改成需要的属性******************************/

      classSource.Append(propertyString("aaa"));

      classSource.Append(propertyString("bbb"));

      classSource.Append(propertyString("ccc"));

      classSource.Append("}");

      System.Diagnostics.Debug.WriteLine(classSource.ToString());

     //编译代码。 

      CompilerResults result = provider.CompileAssemblyFromSource(cp, classSource.ToString());

      if (result.Errors.Count > 0)

      {

     for( int i = 0; i < result.Errors.Count; i ++)

       Console.WriteLine(result.Errors[ i]);

     Console.WriteLine("error");

     return null;

      }

      //获取编译后的程序集。 

      Assembly assembly = result.CompiledAssembly;

      return assembly;

    }

    private static string propertyString(string propertyName)

    {

      StringBuilder sbProperty = new StringBuilder();

      sbProperty.Append(" private  int  _" + propertyName + "  =  0;\n");

      sbProperty.Append(" public  int  " + "" + propertyName + "\n");

      sbProperty.Append(" {\n");

      sbProperty.Append(" get{  return  _" + propertyName + ";}  \n");

      sbProperty.Append(" set{  _" + propertyName + "  =  value;  }\n");

      sbProperty.Append(" }");

      return sbProperty.ToString();

    }


    展开全文
  • 问题:  需要动态为WPF中的DataGrid添加列,并动态绑定相应数据.(此处仅实现动态... 目标继承DynamicObject,添加动态属性集合,并重写方法TrySetMember()和TryGetMember()  public void BtnQuery() {
  • : 定义:class 格式:修饰符 class 类名 【基类、接口】{ 成员 } class test { public string username; public test() { Console.Write("默认构造函数");//构造 } public void ...
  • 在当代的各种高级编程语言中,大多引入了的概念,C#也不例外,也引入了非常丰富的使用。 和对象是面向对象编程中,不得不说的概念。就好比是一张图纸,是设计的抽象的一个设想而已。我们可以依据这个图纸,...
  • C#属性

    2007-03-24 13:49:00
    本节课将介绍C#属性,其目的包括:1.理解什么是属性2.如何实现属性3.创建一个只读属性4.创建一个只写属性属性C#中独具特色的新功能。通过属性来读写中的域,这具有一定的保护功能。在其它语言中,这是通过实现...
  • 根据数据库记录动态生成C#类及其公共属性并动态执行的解决方案
  • 通过C#反射获取属性的描述信息 自定义特性代码 [System.Serializable] [System.AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true, Inherited = false)] ...
  • 今天分享一下c#是如何操作xml的。 大纲: 1.创建XML并实现保存 2.向XML中添加属性 3.向XML中追加内容 4.读取XML文件 5.读取带属性的XML文件,含有移除(有一句提到) 1.创建XML并实现保存 首先,我们要...
  • 问题:  需要动态为WPF中的DataGrid添加列,并动态绑定相应数据.(此处仅实现... 目标继承DynamicObject,添加动态属性集合,并重写方法TrySetMember()和TryGetMember()  --------------- 自测效果: ------
  • C#创建一个学生对象

    2019-08-05 13:47:50
    public class student { public student() { } public string name { get; set; } public string sex { get; set; } //name sex 是学生的属性 ...与Java不一样,Java是先创建属性,再get set ...
  • C#WinForm窗体属性

    2018-04-19 08:57:07
    窗体的基本属性:private void simpleButton3_Click(object sender, EventArgs e) { XtraForm1 TestFm = new XtraForm1(); TestFm.Text = "测试窗体"; TestFm.Owner = this; //设置拥有此窗体的窗体。 ...
  • C# XML添加属性和节点

    2016-02-21 22:31:00
    XmlDocument XmlDoc = new XmlDocument(); XmlDoc.Load("DBConfig.xml"); XmlNode root = XmlDoc.SelectSingleNode("Config"); XmlElement db = XmlDoc.CreateElement("DB");
  • 创建c#文件 文件->新建->项目 创建新的解决方案: 添加到解决方案: 打开最近使用的项目 一般用最近使用的项目,选择打开最近使用文件时,只打开文件,不能运行,运行只能运行解决方案中的项目...
  • 首先介绍一个一般的、非泛型的简化链表,它可以包含任意类型的对象,以后再把这个转化为泛型。 在链表中,一个元素引用下一个元素。所以必须创建一个,它将对象封装在链表中,并引用下一个对象。...
  • C#是一种数据结构,它可以包括数据成员、函数成员(方法、属性、事件、索引器、运算符、实例构造函数、静态构造函数和析构函数)以及嵌套类型。 属性中字段和方法的结合体,通过定义属性,调用该的时候...
  • C#设置窗体属性

    2019-06-10 10:40:22
    每一个 Windows 窗体应用程序都是由若干个窗体构成的,窗体中的属性主要用于设置窗体的外观。 在 Windows 窗体应用程序中右击窗体,在弹出的右键菜单中 选择“属性”命令,弹出如下图所示的属性面板。 窗体的...
  • c#反射 通过类名获取实例和属性,方法 ** 元数据 程序是用来处理数据的,文本和特性都是数据,而我们程序本身(的定义和BLC中的)这些也是数据;有关程序及其类型的数据被称为元数据(metadata),它们保存在...
1 2 3 4 5 ... 20
收藏数 189,624
精华内容 75,849
关键字:

c#创建类属性