В странице справочника удара говорится, что переменный OSTYPE хранит название операционной системы:
OSTYPE
Автоматически набор к строке, которая описывает операционную систему, в которой выполняется удар. Значение по умолчанию системно-зависимо.
Это установлено на linux-gnu
здесь.
C # поддерживает не только переопределение метода, но и скрытие метода. Проще говоря, если метод не переопределяет производный метод, он его скрывает. Метод сокрытия должен быть объявлен с использованием ключевого слова new. Правильное определение класса во втором листинге выглядит следующим образом:
using System;
namespace Polymorphism
{
class A
{
public void Foo() { Console.WriteLine("A::Foo()"); }
}
class B : A
{
public new void Foo() { Console.WriteLine("B::Foo()"); }
}
class Test
{
static void Main(string[] args)
{
A a;
B b;
a = new A();
b = new B();
a.Foo(); // output --> "A::Foo()"
b.Foo(); // output --> "B::Foo()"
a = new B();
a.Foo(); // output --> "A::Foo()"
}
}
}
Я иногда использую ключевое слово new для «ковариации свойств бедняков» в параллельном дереве наследования. Рассмотрим следующий пример:
public interface IDependency
{
}
public interface ConcreteDependency1 : IDependency
{
}
public class Base
{
protected Base(IDependency dependency)
{
MyDependency = dependency;
}
protected IDependency MyDependency {get; private set;}
}
public class Derived1 : Base // Derived1 depends on ConcreteDependency1
{
public Derived1(ConcreteDependency1 dependency) : base(dependency) {}
// the new keyword allows to define a property in the derived class
// that casts the base type to the correct concrete type
private new ConcreteDependency1 MyDependency {get {return (ConcreteDependency1)base.MyDependency;}}
}
Дерево наследования Derived1: Base имеет «параллельную зависимость» от ConcreteDependency1: IDependency ». В производном классе я знаю, что MyDependency имеет тип ConcreteDependency1, поэтому я могу скрыть средство получения свойства из базового класса с помощью ключевого слова new.
EDIT: см. Также это сообщение в блоге Эрика Липперта для хорошее объяснение нового ключевого слова.
Я думаю, что пример ArsenMkrt не совсем верен, по крайней мере, он не полностью объясняет функцию сокрытия. Отбросив ключевое слово new из метода Foo в классе B, вы все равно получите результат
A::Foo()
B::Foo()
A::Foo()
. В языке программирования, таком как Java, где все методы «виртуальные», вы ожидаете получить результат
A::Foo()
B::Foo()
B::Foo()
, взяв Приведенный выше код ArsenMkrt из-за создания экземпляра
A a;
B b;
a = new A();
b = new B();
a.Foo();
b.Foo();
a = new B(); //<< Here
a.Foo();
Однако в его примере вы все равно получаете "A :: Foo ()", потому что в C # методы не виртуальные по умолчанию, и поэтому метод B :: Foo () автоматически скрывает A Foo (). Чтобы добиться полиморфного поведения, нужно вместо этого написать его следующим образом:
class A
{
public virtual void Foo() { Console.WriteLine("A::Foo()"); }
}
class B : A
{
public override void Foo() { Console.WriteLine("B::Foo()"); }
}
Теперь приходит ключевое слово "new". На самом деле, когда вы оставляете "override" из B :: Foo (), вы снова скроете A :: Foo () означает, что вы не t переопределить его поведение по умолчанию, и вы не достигнете полиморфизма, т.е. вы снова получите «A :: Foo ()» в качестве вывода. То же самое может быть достигнуто - и вот где я не на 100% понимаю, почему вы ДОЛЖНЫ это сказать - поместив ключевое слово «новое», например ..
class A
{
public virtual void Foo() { Console.WriteLine("A::Foo()"); }
}
class B : A
{
public new void Foo() { Console.WriteLine("B::Foo()"); }
}
, и вы снова получите результат
A::Foo()
B::Foo()
A::Foo()