C#

namespace general
{
 
class Program
{
static void Main(string[] args)
{

 
//this is what I would like
b myClassAb = new D1();
b newClassAb = myClassAb.Create();
    Console.WriteLine(b.//K is still not avaiable!!}
}


abstract class b
{
    public double KM { get; protected set; }  // C# 2.0 automatic property syntax
    public b Create() { return (b)Activator.CreateInstance(GetType()); }
}

class D1 : b
{
    public D1() { KM = 1.0; }
}
class D2 : b
{
    public D2() { KM = 2.0; }
}

D1 obj = new D1();
D1 obj2 = D1.Create();

D1 obj = new D1();
D1 obj2 = new D1();

abstract class BaseClass
{
    public static T Create<T>() where T : BaseClass, new()
    {
        return new T();
    }
}

class DerivedClass : BaseClass { }

DerivedClass obj = BaseClass.Create<DerivedClass>();

class D1:b
  {
      ..
      public D1 Create() { return new D1(); }
  }
  class D2 : b
  {
      ..
      public D2 Create() { return new D2(); }
  }

D1 obj = new D1();
D1 obj2 = D1.Create();

b myClassAb = new D1();
b newClassAb = myClassAb.Create();
Console.WriteLine(newClassAb.KM); //i.e. I need to access to proprieties, methods, etc of class

Member 4282287 wrote:

I need to access to proprieties, methods, etc of class

b myClassAb = new D1();
b newClassAb = myClassAb.Create();
Console.WriteLine(newClassAb.KM)

b myClassAb = new D1();
Console.WriteLine(myClassAb.KM)

public interface ICalculator
{
    event EventHandler CalculationPerformed;
    event EventHandler<int> CalculatedResult;

    int Add(int Number1, int Number2);
}

public class ManagedClass : ICalculator
{
    public event EventHandler CalculationPerformed;
    public event EventHandler<int> CalculatedResult;

    public int Add(int number1, int number2)
    {
        int result = number1 + number2;
        OnCalculationPerformed(EventArgs.Empty);
        OnCalculatedResult(new EventArgs<int>(result));
        return result;
    }
    protected virtual void OnCalculationPerformed(EventArgs e)
    {
        EventHandler eh = CalculationPerformed;
        if (eh != null)
            eh(this, e);
    }
    protected virtual void OnCalculatedResult(EventArgs<int> e)
    {
        EventHandler<int> eh = CalculatedResult;
        if (eh != null)
            eh(this, e);
    }
}

public delegate void EventHandler<T>(object sender, EventArgs<T> e);
public class EventArgs<T> : EventArgs
{
    private T value;

    public EventArgs(T value)
    {
        this.value = value;
    }

    public T Value
    {
        get { return value; }
    }
}

public static RectangleF Parse(this RectangleF rect, string s)
{
//do something with s
}

public static RectangleF Parse(string s)
{
    RectangleF result = new RectangleF();
    //apply parsed values
    return result;
}

RectangleF rect = RectangleF.Parse("0,0,100,50");

public static class MoreTryParse {
	public static bool TryParse(this RectangleF dummy, string s, out RectangleF rect) {
		float x=0;
		float y=0;
		float w=0;
		float h=0;
		if (s.StartsWith("(") && s.EndsWith(")")) s=s.Substring(1, s.Length-2);
		string[] sa=s.Split(',');
		if (sa.Length==4 && float.TryParse(sa[0], out x) && float.TryParse(sa[1], out y) &&
			float.TryParse(sa[2], out w)&& float.TryParse(sa[3], out h)) {
			rect=new RectangleF(x, y, w, h);
			return true;
		} else {
			rect=new RectangleF(0, 0, 0, 0);
			return false;
		}
	}
}

public void test(string s) {
	RectangleF rect=new RectangleF();
	bool result=rect.TryParse(s, out r1);
	log(s+"  result="+result+"  rect="+rect.ToString());
}