static void Main(string[] args)
{
//HashCode и ссылка на обьект в переменной, например в instanceA - это РАЗНЫЕ ВЕЩИ!
Object instanceA = new MyClassA();
object instanceB = new MyClassB();
//instanceA. - 4 метода: Equals(object), GetHashCode(), GetType(), ToString().
//Object. - 2 статических метода: Equals(object,object) и ReferenceEquals(object, object)
//Object browser => mscorlib[..] => System => Object
// ~Object() - диструктор- это специальный метод, который учавствует в финализации объекта.
// Вызывается автоматически перед тем, как Garbage Collector будет удалять обьект из кучи.
// Equals(object) - виртуальный - ПРАВИЛО: если переопределяется Equals(object), то нужно и переопределить GetHashCode()// проверяет как ReferenceEquals только ссылки.
// Equals(object,object) - статический- ЭТО ОБЕРТКА НАД ОБЫЧНЫМ Equals(object). Когда мы переопределяем Equals(obj) то и Equals(object,object) переопределяется тоже т.к внутри себя использует обычный Equals(obj)
// GetHashCode() -виртуальный- возвращает hash code обьекта - т.е некий номер паспорта -
// GetType() - возращает ссылку на экземпляр класса Type, который нам выдаст всю информацию
// о типе того обьекта(экземпляра), на котором и был вызван этот метод.
// MemberwiseClone() - граф.наследование клонирует ГЛУБОКО, а все ассоциации клонирует ПОВЕРХНОСТНО!
// Смесь ГЛУБОКОГО и ПОВЕРХНОСТНОГО клонирования называется ЧАСТИЧНЫМ(неполным) клонированием.
// Object() - конструктор
// ReferenceEquals(object, object) - статический - сверяет ССЫЛКИ НА обьекты(адреса обьектов на куче).
// Может быть так, что HashCod`ы совпадают и значение в обьектах одинаковое, НО ССЫЛКИ НА ТО ОБЬЕКТЫ РАЗНЫЕ!
// ToString() - виртуальный
//ДВА СТАТИЧЕСИХ: каждый из них имеет 2 аргумента - Equals(object,object) и ReferenceEquals(object, object)
//Три виртуальных: Equals(object), GetHashCode(), ToString()
//Delay
Console.ReadKey();
}
public MyClassA() //StackOverflowExption
{
System.Console.WriteLine("Constructor MyClassA");
// Рефлексивная самоассициация, после первой попытки инстанцирования приводит к цикличному инстранцированию.
my = new MyClassA();
}
public ClassObj()
{
Object instanceA = new MyClassA();
object instanceB = new MyClassB();
Console.ReadLine();
}
public MyClassB(MyClassA a, string z)
{
this.PropertyA = a.PropertyA;
this.PropertyB = a.PropertyB;
// etc.
this.PropertyZ = z;
}
static void Main(string[] args)
{
//Тут будут вызывыться конструкторы по умолчанию, которые будут инициализироваться все поля в классе
//при этом вызывая другие конструкторы!
MyClassA myA = new MyClassA();
MyClassB myB = new MyClassB();
MyClassC myC = new MyClassC();
}
static void Main()
{
Object instanceA = new MyClassA();
object instanceB = new MyClassB();
// Delay.
Console.ReadKey();
}
public void DeclarativeStyle(
MyClassA sut)
{
// Exercise system
var result = sut.Echo("test");
// Verify outcome
result.Should().Be("test");
}
public MyClassB(MyClassB param)
{
Height = param.Height;
paramClassA = new MyClassA();
if (param.paramClassA != null)
{
paramClassA.Width = param.paramClassA.Width;
}
}
public void TestMapping()
{
var a = new MyClassA();
a.MyStruct = new MyStruct("A");
var b = a.Adapt <MyClassB>();
b.MyStruct.Property.ShouldBe("A");
}
public void Merging_Fields()
{
MyClassA defaults = new MyClassA { Param1 = "defaults" };
MyClassA settings = new MyClassA { Param2 = "settings" };
MyClassA results = PropertyMerger.ObjectMerge<MyClassA>(defaults, settings);
Assert.AreEqual("defaults", results.Param1);
Assert.AreEqual("settings", results.Param2);
Assert.AreEqual(null, results.Param3);
}
public void TestMappingToTarget()
{
var a = new MyClassA();
var b = new MyClassB();
a.MyStruct = new MyStruct("A");
a.Adapt(b);
b.MyStruct.Property.ShouldBe("A");
}
public void Calc()
{
MyClassA a = new MyClassA();
try
{
a.Calc();
}
catch (DivideByZeroException d)
{
Console.WriteLine("外側のcatchブロックです");
Console.WriteLine(d.Message);
}
}
public void Merging_Fields()
{
MyClassA defaults = new MyClassA {
Param1 = "defaults"
};
MyClassA settings = new MyClassA {
Param2 = "settings"
};
MyClassA results = CoreUtils.ObjectMerge <MyClassA>(defaults, settings);
Assert.AreEqual("defaults", results.Param1);
Assert.AreEqual("settings", results.Param2);
Assert.AreEqual(null, results.Param3);
}
public static void Main()
{
var actual1 = new List <MyClassA>()
{
new MyClassA(1), new MyClassA(2), new MyClassA(3)
};
var expected1 = new List <MyClassA>()
{
new MyClassA(1), new MyClassA(2), new MyClassA(3)
};
Console.WriteLine(Enumerable.SequenceEqual(actual1, expected1));
var a1 = new MyClassA(1);
var a2 = new MyClassA(2);
var a3 = new MyClassA(3);
var actual2 = new List <MyClassA>()
{
a1, a2, a3
};
var expected2 = new List <MyClassA>()
{
a1, a2, a3
};
Console.WriteLine(Enumerable.SequenceEqual(actual2, expected2));
var actual3 = new List <MyClassB>()
{
new MyClassB(1), new MyClassB(2), new MyClassB(3)
};
var expected3 = new List <MyClassB>()
{
new MyClassB(1), new MyClassB(2), new MyClassB(3)
};
Console.WriteLine(Enumerable.SequenceEqual(actual3, expected3));
var actual4 = new List <MyClassB>()
{
new MyClassB(1), new MyClassB(2), new MyClassB(3)
};
var expected4 = new List <MyClassB>()
{
new MyClassB(3), new MyClassB(2), new MyClassB(1)
};
Console.WriteLine(Enumerable.SequenceEqual(actual4, expected4));
}
static void Main(string[] args)
{
MyClassA a = new MyClassA();
a.Method();
MyClassB b = new MyClassB();
b.Method();
MyClassC c = new MyClassC();
c.Method();
Console.ReadLine();
}
private static void Test02()
{
ClassA a = new ClassA();
lock (a)
{
}
var b = new MyClassA();
var s = new MyStruct();
s.Fun();
MyStruct s1;
s1.Fun();
}
void IBsonSerializer.Serialize(MongoDB.Bson.IO.BsonWriter bsonWriter, Type nominalType, object value, IBsonSerializationOptions options)
{
MyClassA item = (MyClassA)value;
if (item.myClassD != null)
{
using (MemoryStream stream = new MemoryStream())
{
item.myClassD.Save(item.myClassD, stream);
mesure.myClassDBin = stream.ToArray();
}
}
else
{
item.myClassDBin = null;
}
_classMapSerializer.Serialize(bsonWriter, nominalType, item, options);
item.myClassDBin = null;
}
public ActionResult ClassProperty()
{
var cell = new MyClassA();
var result = new StringBuilder();
var properties = cell.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
AjaxMinExtensions.ForEach(properties, prop =>
{
result.Append("<br />");
result.Append($"{prop.Name} {prop.PropertyType} {prop.GetType().IsClass}");
result.Append("<br />");
result.Append($"{prop.PropertyType}");
result.Append("<br />");
result.Append($"{prop.PropertyType.HasElementType}");
result.Append("<br />");
result.Append($"{prop.PropertyType.IsClass}");
});
return(Content($"{result.ToString()}"));
}
static void Main(string[] args)
{
MyClassA myA = new MyClassA();
MyClassB myB = new MyClassB();
}
protected void OnClick(object sender, EventArgs e)
{
MyClassA.Method1();
}
static void Main()
{
MyClassA myA = new MyClassA();
MyClassB myB = new MyClassB();
MyClassC myC = new MyClassC();
}
protected void OnClick(object sender, EventArgs e)
{
Thread.Sleep(1000);
MyClassA.Method1();
}
static void Main()
{
// Попытка инстанцирования класса MyClassA.
MyClassA myA = new MyClassA();
}
public MyClassC(MyClassA a)
{
// Console.WriteLine("called a");
}
public MyClassB()
{
classA = new MyClassA();
}
public MyClassB(MyClassA copy)
{
Property_A = copy.PropertyA;
Property_B = copy.PropertyB;
static void Main(string[] args)
{
Console.WriteLine("Default Interface Methods");
Console.WriteLine();
IMyClassA myClass = new MyClassA();
myClass.Works();
IMyClassB myClassWithMultiInterfacesB = new MyClassWithMultiInterfaces(); // gets the more implicit Interface in multi-hieritance
myClassWithMultiInterfacesB.Works();
IMyClassA myClassWithMultiInterfacesA = new MyClassWithMultiInterfaces(); // gets the more implicit Interface in multi-hieritance
myClassWithMultiInterfacesA.Works();
MyClassWithMultiInterfaces myClassWithMultiInterfaces = new MyClassWithMultiInterfaces();
// myClassWithMultiInterfaces.Works(); <-- compilation error
// when the method is implemented in the class it has more prevalecence than the default method
MyClassWithMutiInterfacesWithNoDefaults myClassWithMutiInterfacesWithNoDefaults = new MyClassWithMutiInterfacesWithNoDefaults();
myClassWithMutiInterfacesWithNoDefaults.Works();
IMyClassA myClassWithMutiInterfacesWithNoDefaultA = new MyClassWithMutiInterfacesWithNoDefaults();
myClassWithMutiInterfacesWithNoDefaultA.Works();
IMyClassC myClassWithMutiInterfacesWithNoDefaultC = new MyClassWithMutiInterfacesWithNoDefaults();
myClassWithMutiInterfacesWithNoDefaultC.Works();
MyClassWithMultiInterfacesAndOverride myClassWithMultiInterfacesAndOverride = new MyClassWithMultiInterfacesAndOverride();
myClassWithMultiInterfacesAndOverride.Works();
IMyClassD myClassD = new MyClassD();
Console.WriteLine($"My name is {myClassD.Name}");
MyClassD myClassD2 = new MyClassD();
// Console.WriteLine($"My name is {myClassD2.Name}"); <-- compilation error
IMyClassAOverride myClassAOverride = new MyClassAOverride();
myClassAOverride.Works();
IMyClassEOverride myClassEOverride = new MyClassEOverride();
myClassEOverride.Works();
// ===============================================================================================
// MIXINS
ILight light = new SimpleLight();
light.SwitchOn();
light.SwitchOff();
ITimerLight timerLight = new TimerLight();
timerLight.DelaySwithOn(1);
timerLight.DelaySwithOff(2);
CrazyLight crazyLight = new CrazyLight();
((IColoredLight)crazyLight).SetColor(COLOR.RED);
((ITimerLight)crazyLight).DelaySwithOn(1);
}
public MyClassC(MyClassA a, MyClassB b)
{
// Console.WriteLine("called a+b");
}
private static void Call()
{
MyClassA.Method1();
}
