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()); } }