-1

このモデルの使用：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace ConsoleApplication1
{
    #region Abstracts definitions
    abstract class AnAbstract
    {
        public string Name { get { return this.GetType().Name; } }
        public bool IsNumeric { get { return this is ANumericAbstract; } }
        public /*abstract*/ string Description = default(string);
    }
    abstract class ANumericAbstract : AnAbstract
    {
        public /*abstract*/ double Min = double.MinValue;
        public /*abstract*/ double Max = double.MaxValue;
    }
    abstract class ANonNumericAbstract : AnAbstract
    {
        public List<Object> objects = new List<Object>();
    }
    #endregion Abstracts definitions
    #region Concrete definitions
    class NumericImpl : ANumericAbstract
    {
        new public const string Description = "A numeric implementation";
        new public const double Min = 0;
        new public const double Max = 1000;
        public NumericImpl()
        {
        }
    }
    abstract class AnotherImpl : ANonNumericAbstract
    {
        public AnotherImpl()
        {
            objects.Add("one");
            objects.Add("two");
            objects.Add("three");
        }
    }
    class SideA : AnotherImpl
    {
        new public const string Description = "Disc side A";
    }
    class SideB : AnotherImpl
    {
        new public const string Description = "Disc side B";
    }
    #endregion Concrete definitions
    partial class Parameter
    {
        public string Name { get; set; }
        public string Description { get; set; }
        public bool IsNumeric { get; private set; }
        public double Min { get; private set; }
        public double Max { get; private set; }
        public List<Object> Values { get; private set; }
        private Parameter()
        {
            Values = new List<Object>();
        }
    }
}

これで、私はいくつかの抽象プロパティ（、、）を持つことができるクラスの階層を定義するふりをし、階層NameのDescription最後IsNumericにそれらのプロパティを強制的に定義するいくつかのクラスがあるはずです。それらの場合、ANumericAbstract追加の特定のプロパティ、たとえばMinおよびを持っている必要がありMaxます。

ここに問題があります。

私は、ジェネリックを取り、そこからいくつかの値を読み取ってプロパティを入力するインスタンスを作成できるようにしようとしてParameterいAnAbstractますParameter。 

Parameter<ANumericAbstract> ParamNum = new Parameter<NumericImpl>();

ここで、Parameterコンストラクターは渡された型を受け取り、「空白を埋める」。言い換えれば、私は次のようなことを試みています：

using System;
namespace ConsoleApplication1 {
    partial class Parameter 
    {
        public static Parameter NewParameter<T>() where T : AnAbstract
        {
            Parameter Parameter = new Parameter();

            // THESE DON'T WORK:
            this.Name = T.Name;
            this.Description = T.Description;
            this.IsNumeric = T.IsNumeric;
            if (this.IsNumeric) 
            {
               this.Min = (T as ANumericAbstract).Min;
               this.Max = (T as ANumericAbstract).Max; 
            }
            else 
            {
              foreach(Object val in (T as ANonNumericAbstract).Values)
              {
                this.Values.Add(val);
              }
            }

            return Parameter;
        }
    }

    class Program
    {
        private AnAbstract Number = new NumericImpl();
        static void Main(string[] args)
        {
        }

        // THESE DON'T WORK:
        private static Parameter<ANumericAbstract> ParameterNum = 
                       Parameter.NewParameter<NumericImpl>();
        private static Parameter<ANonNumericAbstract> ParameterA = 
                       Parameter.NewParameter<SideA>();
        private static Parameter<ANonNumericAbstract> ParameterB = 
                       Parameter.NewParameter<SideB>();
    }
}

明らかに構文は無効ですが、正しい方向に進んでいるかどうかはわかりません。正しく使用していないジェネリック構文はありますか？私はそれで終わり、 JavaのtersGetとSettersを使用する必要がありますか？この時点で、:-)

Parameter par = new Parameter { Name = NumericImpl.Name, /* ... */ };

もっと賢明に見えるかもしれません...

4

1 に答える 1

1

まずNew、プロパティでキーワードを使用しないでください。仮想キーワードを検討してください：

abstract class AnAbstract
{
    public virtual string Name { get { return this.GetType().Name; } }
    public virtual string Description { get { return String.Empty; } }
}
abstract class ANumericAbstract : AnAbstract
{
    public virtual double Min = double.MinValue;
}

class NumericImpl : ANumericAbstract
{
    public override string Description { get { return "A numeric implementation"; } } 
    public override double Min { get { return 0; } }
}

1）入力したインスタンスをParameterコンストラクターに配置し、Parameterインスタンスを作成できます。

partial class Parameter 
{ 
    public Parameter(AnAbstract inputObject) 
    { 
        this.Name = inputObject.Name; 
        // etc
    } 
}

private static Parameter ParameterNum = new Parameter(new NumericImpl());

2）2番目の方法は、リフレクションを使用して、初期パラメーターを持つオブジェクトのインスタンスを作成することです。

    partial class Parameter<T> where T : AnAbstract
    {
        public static Parameter<T> NewParameter<T>() where T : AnAbstract
        {
            Parameter<T> parameter = new Parameter<T>();
            AnAbstract instance = (AnAbstract)Activator.CreateInstance(typeof(T));

            parameter.Name = instance.Name;
            // etc
            return parameter;
        }
    }

    private static Parameter<NumericImpl> ParameterNum = 
        Parameter<NumericImpl>.NewParameter();

3）Parameterクラスを静的にし、静的コンストラクターを介して作成します。

static partial  class Parameter<T> where T : AnAbstract
{
    public static string Name { get; set; }
    //etc
}

static partial class Parameter<T> where T : AnAbstract
{ 
    static Parameter ()
    {
        AnAbstract instance = (AnAbstract)Activator.CreateInstance(typeof(T));
        Parameter<T>.Name = instance.Name;
        //etc
    }
}

最後の例では、次のようにこのクラスを使用できます。

String someName = Parameter<NumericImpl>.Name;
于 2013-03-26T12:45:33.337 に答える