static void Main()
{
// 1
Console.WriteLine("Используем структуру:");
ComplexStruct num1 = new ComplexStruct(1, 2);
ComplexStruct num2 = new ComplexStruct(9, 8);
ComplexStruct num3 = new ComplexStruct();
// 1.1
Console.WriteLine("\tСложение:");
num3 = num1.Plus(num2);
num3.ShowRes();
Console.WriteLine("\tВычитание:");
num3 = num2.Minus(num1);
num3.ShowRes();
// 1.2
Console.WriteLine("Используем класс:");
ComplexClass val1 = new ComplexClass(42, 23);
ComplexClass val2 = new ComplexClass(21, 77);
ComplexClass val3 = new ComplexClass();
Console.WriteLine("\tУмножение:");
val3 = val1.Multi(val2);
val3.ShowRes();
Console.WriteLine("\tВычитание:");
val3 = val2.Minus(val1);
val3.ShowRes();
//Pause
Console.ReadLine();
}
public void Fire3(ComplexStruct p)
{
if (OnEvent03 != null)
{
OnEvent03(p);
}
}
private void IncrementCount()
{
var x = new ComplexStruct();
x.Inner.High = currentCount.Inner.High + 1;
currentCount = x;
}
public void SerializeComplex()
{
var complex = new ComplexStruct
{
array = new ComplexStruct.ArrayElement[] {
new ComplexStruct.ArrayElement {
i = 7,
b = false,
s = null,
},
new ComplexStruct.ArrayElement {
i = -2,
b = true,
s = "some text",
},
},
numbers = new float[] {
0.1f, 1.9f, -99.5f
},
str = "asdad",
empty = new ComplexStruct.Empty()
};
var json = Json.Serialize(complex);
Assert.Equal(
"{\"array\":[{\"i\":7,\"b\":false,\"s\":null},{\"i\":-2,\"b\":true,\"s\":\"some text\"}],\"numbers\":[0.1,1.9,-99.5],\"str\":\"asdad\",\"empty\":{},\"nullArray\":null}",
json
);
}
public void t16_complex_struct()
{
ComplexStruct s = parser.Parse <ComplexStruct>("{\"R\":234,\"V\":123,\"B\":11}");
Assert.AreEqual(234, s.R);
Assert.AreEqual(123, s.V);
Assert.AreEqual(11, s.B);
}
//Realize method Minus(Реализуем метод вычитания)
public ComplexStruct Minus(ComplexStruct x)
{
ComplexStruct y;
y.bi = bi - x.bi;
y.ci = ci - x.ci;
return(y);
}
/*Realize method Plus(Реализуем метод сложения)
* создаем объект "y" присваиваем его переменным значения
*передавая в метод данные присвоенные уже созданному объекту(через конструктор)
*Возвращает объект c полученными переменными.
*/
public ComplexStruct Plus(ComplexStruct x)
{
ComplexStruct y;
y.bi = bi + x.bi;
y.ci = ci + x.ci;
return(y);
}
public ComplexStruct Multi(ComplexStruct x)
{
ComplexStruct y;
y.im = re * x.im + im * x.re;
y.re = re * x.re - im * x.im;
return(y);
}
//Умножение
public ComplexStruct MultiPlus(ComplexStruct x)
{
ComplexStruct y;
y.im = x.im * re + x.re * im;
y.re = x.re * re - x.im * im;
return(y);
}
public ComplexStruct Minus(ComplexStruct x)
{
ComplexStruct y;
y.im = im - x.im;
y.re = re - x.re;
return(y);
}
public void Copy_ConstantExpression_ThrowsException()
{
//Arrange
ComplexStruct complexStructStub = ComplexStructFactory();
//Act, Assert
Exception ex = Assert.Catch(() => complexStructStub.Copy(cs => MAGIC_INT, 20));
}
public ComplexStruct Plus(ComplexStruct x)
{
ComplexStruct y;
y.im = im + x.im;
y.re = re + x.re;
return(y);
}
public void Copy_NullExpression_Succeeds()
{
//Arrange
ComplexStruct complexStructStub = ComplexStructFactory();
//Act
ComplexStruct copy = complexStructStub.Copy(null);
//Assert
Assert.IsTrue(complexStructStub.DeepEquals(copy));
}
public void Copy_IdenticalMultipleExpressions_Fails()
{
//Arrange
ComplexStruct complexStructStub = ComplexStructFactory();
//Act, Assert
Assert.Catch(() => complexStructStub.Copy(new Dictionary <Expression <Func <ComplexStruct, object> >, object>()
{
{ cs => cs.Str, MAGIC_STRING },
{ cs => cs.Str, MAGIC_STRING }
}));
}
public void Copy_UnaryExpressions_AreIgnoredAndValueIsSet()
{
//Arrange
ComplexStruct complexStructStub = ComplexStructFactory();
//Act
ComplexStruct copy = complexStructStub.Copy(cs => (short)(((ComplexStruct)(object)cs).SimpleStruct.Int), MAGIC_INT);
//Assert
Assert.IsFalse(complexStructStub.DeepEquals(copy));
Assert.AreNotEqual(complexStructStub.SimpleStruct.Int, copy.SimpleStruct.Int);
Assert.AreEqual(MAGIC_INT, copy.SimpleStruct.Int);
}
public void Copy_DeepExpression_SetsValue()
{
//Arrange
ComplexStruct complexStructStub = ComplexStructFactory();
//Act
ComplexStruct copy = complexStructStub.Copy(cs => cs.SimpleStruct.Int, MAGIC_INT);
//Assert
Assert.IsFalse(complexStructStub.DeepEquals(copy));
Assert.AreNotEqual(complexStructStub.SimpleStruct.Int, copy.SimpleStruct.Int);
Assert.AreEqual(MAGIC_INT, copy.SimpleStruct.Int);
}
public void Copy_ShallowExpression_SetsValue()
{
//Arrange
ComplexStruct complexStructStub = ComplexStructFactory();
//Act
ComplexStruct copy = complexStructStub.Copy(cs => cs.Str, MAGIC_STRING);
//Assert
Assert.IsFalse(complexStructStub.DeepEquals(copy));
Assert.AreNotEqual(complexStructStub.Str, copy.Str);
Assert.AreEqual(MAGIC_STRING, copy.Str);
}
public void Component_ComplexStruct_AttributeValuesAreResolved()
{
//Arrange
ComplexStruct toSerialize = new ComplexStruct(_fixture.Create <List <int> >());
//Act
var result = AvroConvert.Serialize(toSerialize);
var deserialized = AvroConvert.Deserialize <ComplexStruct>(result);
//Assert
Assert.NotNull(result);
Assert.Equal(toSerialize, deserialized);
}
public void ShouldSerializeComplexStruct()
{
var str = new SimpleStruct {
A = 5,
B = "allman"
};
var compstr = new ComplexStruct {
A = 6,
B = str
};
var newStr = SerializerClone(compstr);
Assert.AreEqual(compstr, newStr);
}
/// <summary>
/// 读数组
/// </summary>
/// <param name="socket"></param>
/// <param name="address">地址格式(MAIN.dint1 (MAIN目录标签 ,dint1在MAIN这个目录定义的dint1这个名)) </param>
/// <returns></returns>
public List <string> ReadArray(TcAdsClient tac, string address)
{
try
{
List <string> list = new List <string>();
int number = tac.CreateVariableHandle(address);
ComplexStruct cs = (ComplexStruct)tac.ReadAny(number, typeof(ComplexStruct));
for (int i = 0; i < cs.dintArr.Length; i++)
{
list.Add(cs.dintArr[i].ToString());
}
return(list);
}
catch
{
return(new List <string>());
}
}
public void Copy_MultipleExpressions_SetValues()
{
//Arrange
ComplexStruct complexStructStub = ComplexStructFactory();
//Act
ComplexStruct copy = complexStructStub.Copy(new Dictionary <Expression <Func <ComplexStruct, object> >, object>()
{
{ cs => cs.Str, MAGIC_STRING },
{ cs => cs.SimpleStruct.Int, MAGIC_INT }
});
//Assert
Assert.AreEqual(MAGIC_STRING, copy.Str);
Assert.AreNotEqual(MAGIC_STRING, complexStructStub.Str);
Assert.AreEqual(MAGIC_INT, copy.SimpleStruct.Int);
Assert.AreNotEqual(MAGIC_INT, complexStructStub.SimpleStruct.Int);
}
//Задание 1а. Демонстрируем работу структуры Complex.
private static void TaskStructCompleks()
{
ComplexStruct complexStruct1;
complexStruct1.im = 1;
complexStruct1.re = 1;
ComplexStruct complexStruct2;
complexStruct2.im = 2;
complexStruct2.re = 2;
ComplexStruct resultPlus = complexStruct1.Plus(complexStruct2);
ComplexStruct resultMinus = complexStruct1.Minus(complexStruct2);
ComplexStruct resultMultiPlus = complexStruct1.MultiPlus(complexStruct2);
Print($"Сумма комплексных чисел: {resultPlus.ComplexStructToString()}.");
Print($"Разность комплексных чисел: {resultMinus.ComplexStructToString()}.");
Print($"Произведение комплексных чисел: {resultMultiPlus.ComplexStructToString()}.");
}
public static void Start()
{
ComplexStruct struct_copmlex = new ComplexStruct(); // значимый тип данных - располагается на стеке вызова внутри процедуры Start
ComplexClass class_complex = new ComplexClass(); // ссылочный тип данных - объекты располагаются в "куче"
// Копирование значения значимого типа данных из одной переменной в другую - длительный процесс если много полей и свойств надо скопировать
// Создание новых объектов значимого типа быстрее, чем для ссылочного типа
// Удаление из памяти для значимого типа гораздо быстрее
// Но! Объём памяти стека ооочень маленький!
var a = new ComplexStruct();
a.Re = 5;
a.Im = 7;
var b = new ComplexStruct();
b.Re = 10;
b.Im = -7;
var a1 = a;
a.Re = 0;
// Копирование ссылочного значения из одной переменной в другую - вопрос комирования 4 байт ссылки. Очень быстро.
var x = new ComplexClass();
x.Re = 5;
x.Im = 7;
var x1 = x;
x.Re = 0;
var y = new ComplexClass();
y.Re = 10;
y.Im = -7;
}
public void ShouldSerializeMultipleObjectsUsingSameStream()
{
var expected1 = new SimpleType {
TextA = "textA", TextB = "hello"
};
var expected2 = new ComplexStruct {
Span = TimeSpan.FromMilliseconds(56), Text = "test"
};
byte[] data;
using (var outputStream = new MemoryStream())
{
_subject.Serialize(outputStream, expected1);
_subject.Serialize(outputStream, expected2);
data = outputStream.ToArray();
}
using (var inputStream = new MemoryStream(data))
{
var deserialized1 = _subject.Deserialize <object>(inputStream);
var deserialized2 = _subject.Deserialize <object>(inputStream);
Assert.That(deserialized1, Is.EqualTo(expected1));
Assert.That(deserialized2, Is.EqualTo(expected2));
}
}
protected override ComplexStruct?GenerateItem() => ComplexStruct.Generate();
public void Multi(ComplexStruct x)
{
this.im = re * x.im + im * x.re;
this.re = re * x.re - im * x.im;
}
public void Subtract(ComplexStruct x)
{
this.im = im - x.im;
this.re = re - x.re;
}
public void Plus(ComplexStruct x)
{
this.im = im + x.im;
this.re = re + x.re;
}
public void ComplexParameterTypes(ComplexClass complexClass, ComplexStruct complexStruct,
ComplexStruct complexNullableStruct)
{
}
public void Fire3(ComplexStruct p)
{
if (OnEvent03 != null) OnEvent03(p);
}
static void Main(string[] args)
{
var unitTest = new ConversionUnitTest();
{
string title = "Primitives";
bool x = false;
int refx = 98;
PrintSend(title, x, refx);
var ret = unitTest.Primitives(x, out char outx, ref refx);
PrintRecv(title, outx, refx, ret);
}
{
string title = "Strings";
var x = "Hello C++";
var refx = "Have A String";
PrintSend(title, x, refx);
var ret = unitTest.Strings(x, out string outx, ref refx);
PrintRecv(title, outx, refx, ret);
}
{
string title = "SimpleStructs";
var x = new BlittableStruct(1, 3, 3, 7);
var refx = new BlittableStruct(8, 8, 8, 8);
PrintSend(title, x, refx);
var ret = unitTest.SimpleStructs(x, out BlittableStruct outx, ref refx);
PrintRecv(title, outx, refx, ret);
}
{
string title = "Objects";
var x = new DummyClass()
{
Nugget = "DummyC#In"
};
var refx = new DummyClass()
{
Nugget = "DummyC#Ref"
};
PrintSend(title, x, refx);
var ret = unitTest.Objects(x, out DummyClass outx, ref refx);
PrintRecv(title, outx, refx, ret);
refx.Dispose();
x.Dispose();
}
{
string title = "NamedDelegates";
NamedDelegate x = (a, b) => a.Length + b.Length;
NamedDelegate refx = (a, b) => (int)a[0] * (int)b[0];
PrintSend(title, x, refx);
var ret = unitTest.NamedDelegates(x, out NamedDelegate outx, ref refx);
PrintRecv(title, outx, refx, ret);
}
{
string title = "ComplexStructs";
var x = new ComplexStruct("ComplexC#In", new BlittableStruct(5, 4, 6, 3), new DummyClass()
{
Nugget = "WelcomeNugget"
}, (u, v) => u | v);
var refx = new ComplexStruct("ComplexC#Ref", new BlittableStruct(9, 0, 0, 9), new DummyClass()
{
Nugget = "RefNugget"
}, (u, v) => u * u * v);
PrintSend(title, x, refx);
var ret = unitTest.ComplexStructs(x, out ComplexStruct outx, ref refx);
PrintRecv(title, outx, refx, ret);
}
{
string title = "PrimitiveArrays";
var x = new bool[] { true, false, false, true, false, true };
var refx = new int[] { 10, 100, 1000, 10000 };
PrintSend(title, x, refx);
var ret = unitTest.PrimitiveArrays(x, out char[] outx, ref refx);
PrintRecv(title, outx, refx, ret);
}
{
string title = "StringArrays";
var x = new string[] { "The", "Quick", "Brown", "Fox" };
var refx = new string[] { "Some", "Strings" };
PrintSend(title, x, refx);
var ret = unitTest.StringArrays(x, out string[] outx, ref refx);
PrintRecv(title, outx, refx, ret);
}
{
string title = "SimpleStructArrays";
var x = new BlittableStruct[] { new BlittableStruct(1001, 1002, 1003, 1004), new BlittableStruct(2001, 2002, 2003, 2004), new BlittableStruct(3001, 3002, 3003, 3004) };
var refx = new BlittableStruct[] { new BlittableStruct(-1, -2, -3, -4), new BlittableStruct(-5, -6, -7, -8) };
PrintSend(title, x, refx);
var ret = unitTest.SimpleStructArrays(x, out BlittableStruct[] outx, ref refx);
PrintRecv(title, outx, refx, ret);
}
{
string title = "ComplexStructArrays";
var x = new ComplexStruct[]
{
new ComplexStruct("ComplexArrC#[0]", new BlittableStruct(-1, 0, 1, 0), new DummyClass()
{
Nugget = "ComplexArrNugget[0]"
}, (a, b) => a * a * b * b),
new ComplexStruct("ComplexArrC#[1]", new BlittableStruct(4, 3, 2, 1), new DummyClass()
{
Nugget = "ComplexArrNugget[1]"
}, (a, b) => b * b - a * a)
};
var refx = new ComplexStruct[]
{
new ComplexStruct("ComplexArrRefC#[0]", new BlittableStruct(11, 12, 13, 14), new DummyClass()
{
Nugget = "ComplexArrRefNugget[0]"
}, (a, b) => a - b)
};
PrintSend(title, x, refx);
var ret = unitTest.ComplexStructArrays(x, out ComplexStruct[] outx, ref refx);
PrintRecv(title, outx, refx, ret);
}
{
string title = "ObjectArrays";
var x = new DummyClass[]
{
new DummyClass()
{
Nugget = "Arr0"
},
new DummyClass()
{
Nugget = "Arr1"
},
null,
new DummyClass()
{
Nugget = "Arr3"
}
};
var refx = new DummyClass[]
{
null,
null
};
PrintSend(title, x, refx);
var ret = unitTest.ObjectArrays(x, out DummyClass[] outx, ref refx);
PrintRecv(title, outx, refx, ret);
}
{
string title = "NamedDelegateArrays";
var x = new NamedDelegate[]
{
(a, b) => a.Length * b.Length,
(a, b) => a.Length + (int)b[0],
};
var refx = new NamedDelegate[]
{
(a, b) => (int)a[0] * (int)b[0]
};
PrintSend(title, x, refx);
var ret = unitTest.NamedDelegateArrays(x, out NamedDelegate[] outx, ref refx);
PrintRecv(title, outx, refx, ret);
}
{
try
{
Func <char[], string> refx = null;
//unitTest.GenericDelegates(null, out var outx, ref refx);
}
catch (Exception e)
{
Console.WriteLine("Caught Exception : " + e.GetType().Name);
}
}
var test = new ITestClass();
Console.WriteLine(string.Format("RO Property = {0}", test.ReadOnlyProperty));
Console.WriteLine(string.Format("Property = {0}", test.Property));
test.Property = 17;
Console.WriteLine(string.Format("Property = {0}", test.Property));
try
{
Console.WriteLine("Testing AccessDeniedException...");
unitTest.ExCheckAccessDenied();
Console.WriteLine("Error: No Exception Thrown!");
}
catch (AccessViolationException e)
{
Console.WriteLine(e.Message);
}
catch (Exception e)
{
Console.WriteLine("ERROR: Improper exception: ");
Console.WriteLine(e.ToString());
}
try
{
Console.WriteLine("Testing ArgumentException...");
unitTest.ExCheckArgument();
Console.WriteLine("Error: No Exception Thrown!");
}
catch (ArgumentException e)
{
Console.WriteLine(e.Message);
}
catch (Exception e)
{
Console.WriteLine("ERROR: Improper exception: ");
Console.WriteLine(e.ToString());
}
try
{
Console.WriteLine("Testing ArgumentNullException...");
unitTest.ExCheckArgumentNull();
Console.WriteLine("Error: No Exception Thrown!");
}
catch (ArgumentNullException e)
{
Console.WriteLine(e.Message);
}
catch (Exception e)
{
Console.WriteLine("ERROR: Improper exception: ");
Console.WriteLine(e.ToString());
}
try
{
Console.WriteLine("Testing Generic Exceptions...");
unitTest.ExCheckGeneric();
Console.WriteLine("Error: No Exception Thrown!");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
try
{
Console.WriteLine("Testing Generic STD Exceptions...");
unitTest.ExCheckGenericStd();
Console.WriteLine("Error: No Exception Thrown!");
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
try
{
Console.WriteLine("Testing InvalidOperationException...");
unitTest.ExCheckInvalidOperation();
Console.WriteLine("Error: No Exception Thrown!");
}
catch (InvalidOperationException e)
{
Console.WriteLine(e.Message);
}
catch (Exception e)
{
Console.WriteLine("ERROR: Improper exception: ");
Console.WriteLine(e.ToString());
}
try
{
Console.WriteLine("Testing NotImplementedException...");
unitTest.ExCheckNotImplemented();
Console.WriteLine("Error: No Exception Thrown!");
}
catch (NotImplementedException e)
{
Console.WriteLine(e.Message);
}
catch (Exception e)
{
Console.WriteLine("ERROR: Improper exception: ");
Console.WriteLine(e.ToString());
}
try
{
Console.WriteLine("Testing NullReferenceException...");
unitTest.ExCheckNullReference();
Console.WriteLine("Error: No Exception Thrown!");
}
catch (NullReferenceException e)
{
Console.WriteLine(e.Message);
}
catch (Exception e)
{
Console.WriteLine("ERROR: Improper exception: ");
Console.WriteLine(e.ToString());
}
}
