(IMyDeviceInterface)Activator.CreateInstance(className);

IT>(IMyDeviceInterface)Activator.CreateInstance(className);
IT>

CreateObject<IMyDeviceInterface>(className);

ГВ>Если бы смысл моей фразы был один, то и спорить было бы не о чем. И извини, но: а) на каком основании ты расписываешься за всех, кто читает этот топик, и б) смысл своей фразы буду объяснять я,

ГВ>Напиши-ка мне то же самое на дотнете, но без использования визуального редактора?

public void EditObject(object o, Form editForm)
{
    foreach (PropertyInfo pi in o.GetType().GetProperties())
    {
        TextBox tx = new TextBox();
        tx.Text = TypeDescriptor.GetConverter(o.GetType()).ConvertToString();
        tx.Tag = pi;
        editForm.Controls.Add(tx);
    }
    
    if (editForm.ShowDialog == DialogResult.OK)
        foreach (Control ctrl in editForm.Controls)
        {
            TextBox tx = ctrl as TextBox;
            if (tx != null)
                ((PropertyInfo)tx.Tag).SetValue(o, TypeDescriptor.ConvertFromString(tx.Text));
        }
}

ГВ>Да, но ты, в частности, демонстрируешь или непонимание, или упорное нежелание понять. Вот я и объясняю. Я согласен, мы все не идеальны и у всех разные стереотипы, потому я, например, и склонен уточнять и разъяснять формулировки ровно столько, сколько необходимо.

public interface ISomeObj
{
    int Y(int x);
    // Согласись - сказать меняет этот метод состояние объекта или нет заранее невозможно
}

...

private void SomeMethod(const ISomeObj someObj)
{
    int y = someObj.Y(25);
    // А вот теперь объясни мне - как компилятор может узнать - нарушает ли это выражение константный констрейн или нет?
}

S>interface ISome {
S>  int GetProperty() const;
S>    void SetProperty(int v);
S>}
S>

S>void XXX::SomeMethod(const ISome some)
S>{
S>    some.GetProperty(); // ok
S>    some.SetProperty(5); // нельзя. 

Собственно почему нельзя? Как ты это определил? По наличию префикса Set в имени метода?

S>}
S>

S>class ISomeConstWrapper {
S>private
S>  ISome _wrapped;
S>public
S>  ISomeConstWrapper(ISome wrapped) {}
S>  int GetProperty() {return _wrapped.GetProperty();}
S>}
S>void XXX::SomeMethod(ISomeConstWrapper some)
S>{
S>...
S>}
S>

When a field-declaration includes a readonly modifier, the fields introduced by the declaration are readonly fields. Direct assignments to readonly fields can only occur as part of that declaration or in an instance constructor or static constructor in the same class. (A readonly field can be assigned to multiple times in these contexts.) Specifically, direct assignments to a readonly field are permitted only in the following contexts:

In the variable-declarator that introduces the field (by including a variable-initializer in the declaration).
For an instance field, in the instance constructors of the class that contains the field declaration; for a static field, in the static constructor of the class that contains the field declaration. These are also the only contexts in which it is valid to pass a readonly field as an out or ref parameter.
Attempting to assign to a readonly field or pass it as an out or ref parameter in any other context is a compile-time error.

int main()
{
 Base *pb,*pd;
 pb=new Base(10);        // Create an instance of Base. Nothing unusual.
 pb->f();                   // Base::f()

 pd=new("Derived") Base(4); // Create an instance of Derived.
                            // Actually Derived(4) will be called.

 pd->f();                   // Derived::f()
 delete pd;                 // Destructors are virtual so Derived::~Derived
 delete pb;                 // Base::~Base
};