This example demonstrates how abstract classes are ported to C++. They are declared using macro ABSTRACT which expands into __declspec(novtable) for Microsoft VC++. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace TypesPorting { public abstract class AbstractClassWithoutMethods { } public abstract class AbstractClassWithMethods { public abstract void SomeAbstractMethod(); public virtual void SomeVirtualMethod() { } public void SomeMethod() { } } } Ported Code C++ Header #pragma once #include <system/object. Read More »

This example demonstrates how break statement inside loop is ported to C++. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; namespace StatementsPorting { public class BreakStatements { public void BreakForeach(int[] values, int max) { foreach (int value in values) { Console.WriteLine(value); if (value > max) break; } } public void BreakEnclosedForeach(int[][] values, int max) { foreach (int[] row in values) { if (row.Length == 0) break; foreach (int value in row) { Console. Read More »

This example demonstrates how class auto properties are ported to C++. Public, protected and private properties preserve their accessibility level. Internal properties become protected. Getters are ported to methods with prefix get_ and setters with prefix set_. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace MembersPorting { public class ClassAutoProperties { public int PublicProperty { get; set; } internal string InternalProperty { get; set; } protected bool ProtectedProperty { get; set; } private double PrivateProperty { get; set; } } } Ported Code C++ Header #pragma once #include <system/string. Read More »

This example demonstrates how class constructors are ported to C++. Public, protected and private constructors preserve their accessibility level. Internal constructors become protected. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace MembersPorting { public class ClassConstructors { public ClassConstructors() { } public ClassConstructors(string value) { } internal ClassConstructors(int value) { } protected ClassConstructors(bool value) { } private ClassConstructors(double value) { } } } Ported Code C++ Header #pragma once #include <system/object. Read More »

This example demonstrates how class events are ported to C++. Public, protected and private class events preserve their accessibility level. Internal class events become protected. Events are ported to fields of type System::Eventwhich is a part of asposecpplib. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace MembersPorting { public delegate void SomeDelegate(); public class ClassEvents { public event SomeDelegate PublicEvent; internal event SomeDelegate InternalEvent; protected event SomeDelegate ProtectedEvent; private event SomeDelegate PrivateEvent; } } Ported Code C++ Header #pragma once #include <system/object. Read More »

This example demonstrates how class finalizer is ported to C++. In C++ it becomes class destructor. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace MembersPorting { public class ClassFinalizers { ~ClassFinalizers() { /* do nothing */ } } } Ported Code C++ Header #pragma once #include <system/object.h> namespace MembersPorting { class ClassFinalizers : public System::Object { typedef ClassFinalizers ThisType; typedef System::Object BaseType; typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo; RTTI_INFO_DECL(); public: virtual ~ClassFinalizers(); }; } // namespace MembersPorting C++ Source Code #include "ClassFinalizers. Read More »

This example demonstrates how generic class methods are ported to C++. In C++ they become template methods. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; namespace MembersPorting { public class ClassGenericMethods { public void NongenericMethod() { } public void GenericMethod<T>(T value) { } public void GenericMethodWithTypeConstraint<T>(T value) where T : ICloneable { } public void GenericMethodWithClassConstraint<T>(T value) where T : class { } public void GenericMethodWithStructConstraint<T>(T value) where T : struct { } public void GenericMethodWithNewConstraint<T>(T value) where T : new() { } public void GenericMethodWithSeveralConstraint<T>(T value) where T : class, ICloneable, new() { } } } Ported Code C++ Header #pragma once #include <system/object. Read More »

This example demonstrates how class indexers are ported to C++. Public, protected and private indexers preserve their accessibility level. Internal indexers become protected. Each indexer is ported into two methods: idx_get and idx_set. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace MembersPorting { public class ClassIndexers { public int this[int index] { get { return 0; } set { /* do nothing */ } } internal string this[string index] { get { return "iddqd"; } set { /* do nothing */ } } protected bool this[bool index] { get { return true; } set { /* do nothing */ } } private object this[object index] { get { return new object(); } set { /* do nothing */ } } } } Ported Code C++ Header #pragma once #include <system/object. Read More »

This example demonstrates how class methods are ported to C++. Public, protected and private methods preserve their accessibility level. Internal methods become protected. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace MembersPorting { public class ClassMethods { public void PublicMethod() { } internal void InternalMethod() { } protected void ProtectedMethod() { } private void PrivateMethod() { } } } Ported Code C++ Header #pragma once #include <system/object. Read More »

This example demonstrates how class properties which have explicitly defined setters and getters are ported. Properties may have getter, setter, or both. Public, protected and private properties preserve their accessibility level. Internal properties become protected. Getters are ported to methods with prefix get_ and setters with prefix set_. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace MembersPorting { public class ClassProperties { public int PublicProperty { get { return mPublicPropertyField; } set { mPublicPropertyField = value; } } public int PublicPropertyWithoutSetter { get { return mPublicPropertyField; } } public int PublicPropertyWithoutGetter { set { mPublicPropertyWithoutGetterField = value; } } internal string InternalProperty { get { return mInternalPropertyField; } set { mInternalPropertyField = value; } } protected bool ProtectedProperty { get { return mProtectedPropertyField; } set { mProtectedPropertyField = value; } } private double PrivateProperty { get { return mPrivatePropertyField; } set { mPrivatePropertyField = value; } } private int mPublicPropertyField; private int mPublicPropertyWithoutSetterField; private int mPublicPropertyWithoutGetterField; private string mInternalPropertyField; private bool mProtectedPropertyField; private double mPrivatePropertyField; } } Ported Code C++ Header #pragma once #include <system/string. Read More »

This example demonstrates how static class constructor is ported to C++. A static field with special name s_constructor__ of special type __StaticConstructor__ is added. The code is executed on program startup and this behavior is different from C# static constructors which are called right before first class usage. Additional command-line options passed to CsToCppPorter: none. Source C# Code using NUnit.Framework; namespace MembersPorting { public class ClassStaticConstructor { static ClassStaticConstructor() { } } public static class DeletedConstructor { static void Foo() { } } public static class StaticConstructorExists { static readonly bool Foo; static void Bar() { } static StaticConstructorExists() { Foo = false; } } [TestFixture] public static class NonDeletedConstructor { } [CsToCppPorter. Read More »

This example demonstrates how class static methods are ported to C++. Public, protected and private static methods preserve their accessibility level. Internal static methods become protected. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace MembersPorting { public class ClassStaticMethods { public static void PublicMethod() { } internal static void InternalMethod() { } protected static void ProtectedMethod() { } private static void PrivateMethod() { } } } Ported Code C++ Header #pragma once #include <system/object. Read More »

This example demonstrates how class static properties are ported. Static properties may have getter, setter, or both. Public, protected and private static properties preserve their accessibility level. Internal static properties become protected. Getters are ported to static methods with prefix get_ and setters with prefix set_. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace MembersPorting { public class ClassStaticProperties { public static int PublicProperty { get; set; } internal static string InternalProperty { get; set; } protected static int ProtectedProperty { get; set; } private static int PrivateProperty { get; set; } } } Ported Code C++ Header #pragma once #include <system/string. Read More »

This example demonstrates how virtual class methods are ported to C++. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace MembersPorting { public class ClassVirtualMethods { public virtual void VirtualMethod() { } public virtual void OtherVirtualMethod(int value) { } } } Ported Code C++ Header #pragma once #include <system/object.h>#include <cstdint> namespace MembersPorting { class ClassVirtualMethods : public System::Object { typedef ClassVirtualMethods ThisType; typedef System::Object BaseType; typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo; RTTI_INFO_DECL(); public: virtual void VirtualMethod(); virtual void OtherVirtualMethod(int32_t value); }; } // namespace MembersPorting C++ Source Code #include "ClassVirtualMethods. Read More »

This example demonstrates how continue statement inside loop is ported to C++. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; namespace StatementsPorting { public class ContinueStatements { public void ContinueForeach(int[] values, int max) { foreach (int value in values) { if (value > max) continue; Console.WriteLine(value); } } public void ContinueEnclosedForeach(int[][] values, int max) { foreach (int[] row in values) { if (row.Length == 0) continue; foreach (int value in row) { if (value > max) continue; Console. Read More »

This example demonstrates how delegates are ported to C++. They are declared using special type System::MulticastDelegatefrom asposecpplib. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace TypesPorting { public delegate void Delegate1(); public delegate int Delegate2(); public delegate void Delegate3(string arg1, int arg2); public delegate int Delegate4(string arg1, int arg2); public delegate int Delegate5(out string arg1, ref int arg2); } Ported Code C++ Header #pragma once #include <system/string. Read More »

This example demonstrates how do-while statement is ported to C++. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; namespace StatementsPorting { public class DoWhileStatements { public void DoWhile(int max) { int number = 0; do { Console.WriteLine(number); ++number; } while (number < max); } public void EnclosedDoWhile(int max1, int max2) { int number1 = 0; do { int number2 = 0; do { Console.WriteLine(number1 + number2); ++number2; } while (number2 < max2); ++number1; } while (number1 < max1); } public void InfiniteDoWhile() { do { Console. Read More »

This example demonstrates how C# enums are ported to C++. Flags enums have additional declarations for supporting logical operations. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; namespace TypesPorting { public enum SimpleEnum { Value1 = 1, Value2, Value3 = 100, Value4 = -1, Value5 = -Value3, Value6 = -5, Value7 = 7 } public enum EnumWithType : uint { Value1 = 1, Value2, Value3 = 100, Value4 = SimpleEnum. Read More »

This example demonstrates how C# enum type cast expression is ported to C++. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace StatementsPorting { public enum SomeEnum { Value1 = 1, Value3 = 3, Value13 = 13 } public class EnumTypeCast { public void EnumToNumberCasts() { SomeEnum source = SomeEnum.Value13; sbyte dest1 = (sbyte) source; byte dest2 = (byte) source; short dest3 = (short) source; ushort dest4 = (ushort) source; int dest5 = (int) source; uint dest6 = (uint) source; long dest7 = (long) source; ulong dest8 = (ulong) source; float dest9 = (float) source; double dest10 = (double) source; char dest11 = (char) source; } public void NumberEnumToCasts() { sbyte source1 = -11; byte source2 = 13; short source3 = -333; ushort source4 = 666; int source5 = -333333; uint source6 = 666666; long source7 = -333333333; ulong source8 = 666666666; float source9 = 3. Read More »

This example demonstrates how exceptions are ported to C++. They become C++ classes which are inherited from System::Exception. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; using System.Runtime.Serialization; namespace TypesPorting { public class SimpleCustomException : Exception { } public class CustomMessageException : Exception { public CustomMessageException() { } public CustomMessageException(string message) : base(message) { } } public class CustomMessageInnerException : Exception { public CustomMessageInnerException() { } public CustomMessageInnerException(string message) : base(message) { } public CustomMessageInnerException(string message, Exception innerException) : base(message, innerException) { } } public class CustomMessageInnerExceptionInhetor : CustomMessageInnerException { CustomMessageInnerExceptionInhetor(string res) : base(res, null) { } } internal class BaseException : Exception { public BaseException() { } protected BaseException(SerializationInfo info, StreamingContext context) : base(info,context) { } } internal class BadArgumentException : BaseException { //now generating 'friend class Details_BadArgumentException;' on BaseException without forward declaration //for 'friend class Details_BadArgumentException;' compilier need forward declaration Details_BadArgumentException //so forward declaration Details_BadArgumentException and alias BadArgumentException before defining need to take up protected BadArgumentException(SerializationInfo info, StreamingContext context) : base(info, context) { } } // No fields, no ctors public class Exception1 : Exception { } // Some field, no ctors public class Exception2 : Exception { public int field; } // No fields, static ctor public class Exception3 : Exception { static Exception3() { } } // Some field, static ctor public class Exception4 : Exception { static readonly long field; static Exception4() { field = 0; } } // No fields, normal ctor public class Exception5 : Exception { public Exception5() { } } // Some field, normal ctor public class Exception6 : Exception { public int field; public Exception6() { field = -1; } } // No fields, static and normal ctors public class Exception7 : Exception { static Exception7() { } public Exception7() { } } // Some fields, static and normal ctors public class Exception8 : Exception { static readonly long field1; public int field2; static Exception8() { field1 = 0; } public Exception8() { field2 = -1; } } } Ported Code C++ Header #pragma once #include <system/exceptions. Read More »

This example demonstrates how NUnit test with expected exception attribute applied is ported to C++. Googletest C++ library is used to translate NUnit tests to C++. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; using NUnit.Framework; namespace NUnitTestsPorting { [TestFixture] public class ExpectedException { [Test] [ExpectedException] public void TestMethod1() { } [Test] [ExpectedException(typeof(InvalidOperationException))] public void TestMethod2() { } [Test] [ExpectedException("System.InvalidOperationException")] public void TestMethod3() { } [Test] [ExpectedException(typeof(InvalidOperationException), ExpectedMessage = "expected message")] public void TestMethod4() { } [Test] [ExpectedException(typeof(InvalidOperationException), ExpectedMessage = "expected message", MatchType = MessageMatch. Read More »

This example demonstrates how foreach statement is ported to C++. It is translated to C++ for statement. Additional command-line options passed to CsToCppPorter: -o foreach_as_range_based_for_loop=true. Source C# Code using System; using System.Collections; using System.Collections.Generic; using CsToCppPorter; namespace StatementsPorting { public class ForeachStatements : IEnumerable<string> { [CppGenerateBeginEndMethods] private List<string> m_collection; public IEnumerator<string> GetEnumerator() { return m_collection.GetEnumerator(); } [CppSkipEntity] IEnumerator IEnumerable.GetEnumerator() { return null; } public void Foreach(string[] values) { foreach (string value in values) { Console. Read More »

This example demonstrates how for statement is ported to C++. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; namespace StatementsPorting { public class ForStatements { public void For(int count) { for (int index = 0; index < count; ++index) { Console.WriteLine(index); } } public void ForWithSeveralCounter(int count1, int count2) { for (int index1 = 0, index2 = 0; index1 < count1 && index2 < count2; ++index1, ++index2) { Console. Read More »

This example demonstrates how generic classes are ported to C++. They become C++ template classes which are inherited from System::Object and have RTTI declared. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; namespace TypesPorting { public class GenericClass<TInner> { } public class GenericClassWithTypeConstraint<TInner> where TInner : ICloneable { } public class GenericClassWithClassConstraint<TInner> where TInner : class { } public class GenericClassWithStructConstraint<TInner> where TInner : struct { } public class GenericClassWithNewConstraint<TInner> where TInner : new() { } public class GenericClassWithSeveralConstraints<TInner> where TInner : class, ICloneable, new() { } } Ported Code C++ Header #pragma once #include <system/object. Read More »

This example demonstrates how generic delegates are ported to C++. They are declared using special type System::MulticastDelegatefrom asposecpplib. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; namespace TypesPorting { public delegate TOut GenericDelegate<TIn, TOut>(TIn value); public delegate TOut GenericDelegateWithTypeConstraint<TIn, TOut>(TIn value) where TIn : ICloneable where TOut : IConvertible; public delegate TOut GenericDelegateWithClassConstraint<TIn, TOut>(TIn value) where TIn : class where TOut : class; public delegate TOut GenericDelegateWithStructConstraint<TIn, TOut>(TIn value) where TIn : struct where TOut : struct; public delegate TOut GenericDelegateWithNewConstraint<TIn, TOut>(TIn value) where TIn : new() where TOut : new(); public delegate TOut GenericDelegateWithSeveralConstraints<TIn, TOut>(TIn value) where TIn : class, ICloneable, new() where TOut : struct, IConvertible; } Ported Code C++ Header #pragma once #include <system/object. Read More »

This example demonstrates how generic interfaces are ported to C++. They become C++ template classes which are inherited from System::Object and have RTTI declared. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; namespace TypesPorting { public interface IGenericInterface<TInner> { } public interface IGenericInterfaceWithTypeConstraint<TInner> where TInner : ICloneable { } public interface IGenericInterfaceWithClassConstraint<TInner> where TInner : class { } public interface IGenericInterfaceWithStructConstraint<TInner> where TInner : struct { } public interface IGenericInterfaceWithNewConstraint<TInner> where TInner : new() { } public interface IGenericInterfaceWithSeveralConstraints<TInner> where TInner : class, ICloneable, new() { } } Ported Code C++ Header #pragma once #include <system/object. Read More »

This example demonstrates how C# generic structs are ported to C++. They become C++ template classes which are inherited from System::Object and have RTTI declared. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; namespace TypesPorting { public struct GenericStruct<TInner> { } public struct GenericStructWithTypeConstraint<TInner> where TInner : ICloneable { } public struct GenericStructWithClassConstraint<TInner> where TInner : class { } public struct GenericStructWithStructConstraint<TInner> where TInner : struct { } public struct GenericStructWithNewConstraint<TInner> where TInner : new() { } public struct GenericStructWithSeveralConstraints<TInner> where TInner : class, ICloneable, new() { } } Ported Code C++ Header #pragma once #include <system/object. Read More »

This example demonstrates how if statement is ported to C++. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; namespace StatementsPorting { public class IfStatements { public void If(int value) { if (value >= 666) Console.WriteLine("iddqd"); } public void IfElse(int value) { if (value <= 666) Console.WriteLine("iddqd"); else Console.WriteLine("idkfa"); } public void SeveralIfElse(int value) { if (value < 3) Console.WriteLine("iddqd"); else if (value < 13) Console.WriteLine("idkfa"); else if (value < 33) Console. Read More »

This example demonstrates how C# lambda expressions are ported to C++. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; using System.Collections.Generic; using System.Linq; namespace StatementsPorting { public class LambdaExpressions { public void LambdaWithReturnValueExpressions() { int delta = 767; SomeCalculation(SomeSelector); SomeCalculation(value => value + 2); SomeCalculation(value => value + delta); SomeCalculation(value => value + mSomeDelta); SomeCalculation(_ => 777); Func<int, int> selector1 = SomeSelector; SomeCalculation(selector1); Func<int, int> selector2 = value => value + 2; SomeCalculation(selector2); Func<int, int> selector3 = value => value + delta; SomeCalculation(selector3); Func<int, int> selector4 = value => value + mSomeDelta; SomeCalculation(selector4); Func<int, int> selector5 = _ => 777; SomeCalculation(selector5); } public void LambdaWithoutReturnValueExpressions() { int delta = 767; SomeProcessor(SomeAction); SomeProcessor(value => Console. Read More »

This example demonstrates how nested classes are ported to C++. Public, protected and private classes preserve their accessibility level. Internal classes become protected. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace TypesPorting { public class OuterClass { public class PublicNestedClass { } internal class InternalNestedClass { } protected class ProtectedNestedClass { } private class PrivateNestedClass { } } } Ported Code C++ Header #pragma once #include <system/object. Read More »

This example demonstrates how return statement is ported to C++. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; namespace StatementsPorting { public class ReturnStatements { public void ReturnVoid(int value) { if (value < 10) return; Console.WriteLine(value); } public int ReturnValue(int value) { if (value < 10) return 666; Console.WriteLine(value); return 13; } } } Ported Code C++ Header #pragma once #include <system/object.h>#include <cstdint> namespace StatementsPorting { class ReturnStatements : public System::Object { typedef ReturnStatements ThisType; typedef System::Object BaseType; typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo; RTTI_INFO_DECL(); public: void ReturnVoid(int32_t value); int32_t ReturnValue(int32_t value); }; } // namespace StatementsPorting C++ Source Code #include "ReturnStatements. Read More »

This example demonstrates how simple C# class is ported to C++. A result C++ class inherits System::Object class and contains definitions for RTTI. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace TypesPorting { public class SimpleClass { } } Ported Code C++ Header #pragma once #include <system/object.h> namespace TypesPorting { class SimpleClass : public System::Object { typedef SimpleClass ThisType; typedef System::Object BaseType; typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo; RTTI_INFO_DECL(); }; } // namespace TypesPorting C++ Source Code #include "SimpleClass. Read More »

This example demonstrates how interfaces are ported to C++. They become C++ classes which are inherited from System::Object and have RTTI declared. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace TypesPorting { public interface ISimpleInterface { } } Ported Code C++ Header #pragma once #include <system/object.h> namespace TypesPorting { class ISimpleInterface : public System::Object { typedef ISimpleInterface ThisType; typedef System::Object BaseType; typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo; RTTI_INFO_DECL(); }; } // namespace TypesPorting C++ Source Code #include "ISimpleInterface. Read More »

This example demonstrates how simple C# struct is ported to C++. A result C++ class inherits System::Object class and contains definitions for RTTI. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace TypesPorting { public struct SimpleStruct { } } Ported Code C++ Header #pragma once #include <system/object.h> namespace TypesPorting { class SimpleStruct : public System::Object { typedef SimpleStruct ThisType; typedef System::Object BaseType; typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo; RTTI_INFO_DECL(); public: SimpleStruct(); }; } // namespace TypesPorting C++ Source Code #include "SimpleStruct. Read More »

This example demonstrates how simple NUnit test is ported to C++. Googletest C++ library is used to translate NUnit tests to C++. Additional command-line options passed to CsToCppPorter: none. Source C# Code using NUnit.Framework; namespace NUnitTestsPorting { [TestFixture] public class SimpleTest { [Test] public void T1() { } } } Ported Code C++ Header #pragma once #include <system/object.h>#include <gtest/gtest.h> namespace NUnitTestsPorting { class SimpleTest : public System::Object { typedef SimpleTest ThisType; typedef System::Object BaseType; typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo; RTTI_INFO_DECL(); public: void T1(); }; } // namespace NUnitTestsPorting C++ Source Code #include "SimpleTest. Read More »

This example demonstrates how C# standard type cast expression is ported to C++. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace StatementsPorting { public class StandardTypeCast { public void SByteTypeCasts() { sbyte source = -11; // implicit casts short dest1 = source; int dest2 = source; long dest3 = source; float dest4 = source; double dest5 = source; // explicit casts byte dest6 = (byte) source; ushort dest7 = (ushort) source; uint dest8 = (uint) source; ulong dest9 = (ulong) source; char dest10 = (char) source; } public void ByteTypeCasts() { byte source = 13; // implicit casts short dest1 = source; ushort dest2 = source; int dest3 = source; uint dest4 = source; long dest5 = source; ulong dest6 = source; float dest7 = source; double dest8 = source; // explicit casts sbyte dest9 = (sbyte) source; char dest10 = (char) source; } public void ShortTypeCasts() { short source = -333; // implicit casts int dest1 = source; long dest2 = source; float dest3 = source; double dest4 = source; // explicit casts sbyte dest5 = (sbyte) source; byte dest6 = (byte) source; ushort dest7 = (ushort) source; uint dest8 = (uint) source; ulong dest9 = (ulong) source; char dest10 = (char) source; } public void UShortTypeCasts() { ushort source = 666; // implicit casts int dest1 = source; uint dest2 = source; long dest3 = source; ulong dest4 = source; float dest5 = source; double dest6 = source; // explicit casts sbyte dest7 = (sbyte) source; byte dest8 = (byte) source; short dest9 = (short) source; char dest10 = (char) source; } public void IntTypeCasts() { int source = -333333; // implicit casts long dest1 = source; float dest2 = source; double dest3 = source; // explicit casts sbyte dest4 = (sbyte) source; byte dest5 = (byte) source; short dest6 = (short) source; ushort dest7 = (ushort) source; uint dest8 = (uint) source; ulong dest9 = (ulong) source; char dest10 = (char) source; } public void UIntTypeCasts() { uint source = 666666; // implicit casts; long dest1 = source; ulong dest2 = source; float dest3 = source; double dest4 = source; // explicit casts sbyte dest5 = (sbyte) source; byte dest6 = (byte) source; short dest7 = (short) source; ushort dest8 = (ushort) source; int dest9 = (int) source; char dest10 = (char)source; } public void LongTypeCasts() { long source = -333333333; // implicit casts float dest1 = source; double dest2 = source; // explicit casts sbyte dest3 = (sbyte) source; byte dest4 = (byte) source; short dest5 = (short) source; ushort dest6 = (ushort) source; int dest7 = (int) source; uint dest8 = (uint) source; ulong dest9 = (ulong) source; char dest10 = (char) source; } public void ULongTypeCasts() { ulong source = 666666666; // implicit casts; float dest1 = source; double dest2 = source; // explicit casts sbyte dest3 = (sbyte) source; byte dest4 = (byte) source; short dest5 = (short) source; ushort dest6 = (ushort) source; int dest7 = (int) source; uint dest8 = (uint) source; long dest9 = (long) source; char dest10 = (char)source; } public void FloatTypeCasts() { float source = 3. Read More »

This example demonstrates how static classes are ported to C++. They are not inherited from System::Object unlike others and have no RTTI declared. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace TypesPorting { public static class StaticClass { public static void StaticMethod() { } } } Ported Code C++ Header #pragma once namespace TypesPorting { class StaticClass { typedef StaticClass ThisType; public: static void StaticMethod(); public: StaticClass() = delete; }; } // namespace TypesPorting C++ Source Code #include "StaticClass. Read More »

This example demonstrates how switch statement is ported to C++. Switch statement with stings is translated to C++ if statement. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; using System.Collections.Generic; namespace StatementsPorting { public enum SomeEnum { InitValue = 0, Value = 1, SomeValue =2, OtherValue = 3, YetOneValue = 4, AnotherValue = 5 } public class SwitchStatements { public void IntSwitch(int value) { switch (value) { case 3: Console. Read More »

This example demonstrates how NUnit test fixture with SetUp method is ported to C++. Googletest C++ library is used to translate NUnit tests to C++. SetUp, TearDown, TestFixtureSetUp, and TestFixtureTearDown methods are supported and translated to corresponding methods of googletest. Additional command-line options passed to CsToCppPorter: none. Source C# Code using NUnit.Framework; namespace NUnitTestsPorting { [TestFixture] public class TestWithSetupMethods { [SetUp] public void Setup() { mValue += 1; } [TearDown] public void TearDown() { mValue -= 1; } [TestFixtureSetUp] public void GlobalSetup() { mValue += 10; } [TestFixtureTearDown] public void GlobalTearDown() { mValue -= 10; } [Test] public void TestMethod() { } private int mValue = 0; } } Ported Code C++ Header #pragma once #include <system/object. Read More »

This example demonstrates how throw statement is ported to C++. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; namespace StatementsPorting { public class SomeException : Exception { } public class OtherException : Exception { } public class ThrowStatements { public void Throw(int value) { if (value < 10) { Console.WriteLine("Too small value"); throw new SomeException(); } if (value > 20) { Console.WriteLine("Too big value"); throw new OtherException(); } } public void RethrowSame() { try { InnerMethod(); } catch (SomeException) { Console. Read More »

This example demonstrates how try-catch-finally statement is ported to C++. They are translated to lambda expressions passed to System::DoTryFinally function. Additional command-line options passed to CsToCppPorter: -o finally_statement_as_lambda=true. Source C# Code using System; namespace StatementsPorting { public class GrandParentException : Exception { } public class ParentException : GrandParentException { } public class ChildException : ParentException { } public class TryCatchFinallyStatements { public void TryCatchFinally() { try { InnerMethod(); } catch (ChildException) { Console. Read More »

This example demonstrates how try-catch statement is ported to C++. Additional command-line options passed to CsToCppPorter: -o finally_statement_as_lambda=true. Source C# Code using System; namespace StatementsPorting { public class GrandParentException : Exception { } public class ParentException : GrandParentException { } public class ChildException : ParentException { } public class TryCatchStatements { public void TryCatch() { try { InnerMethod(); } catch (ChildException) { Console.WriteLine("Catch ChildException"); } catch (ParentException) { Console.WriteLine("Catch ParentException"); } catch (GrandParentException) { Console. Read More »

This example demonstrates how try-finally statement is ported to C++. They are translated to lambda expressions passed to System::DoTryFinally function. Additional command-line options passed to CsToCppPorter: -o finally_statement_as_lambda=true. Source C# Code using System; namespace StatementsPorting { public class TryFinallyStatements { public void TryFinally() { try { InnerMethod(); } finally { Console.WriteLine("Finally"); } } public void TryFinallyWithException() { try { InnerMethod(); } finally { Console.WriteLine("Finally"); throw new Exception(); } } public void EnclosedTryFinally() { try { try { InnerMethod(); } finally { Console. Read More »

This example demonstrates how var expression is ported to C++. Additional command-line options passed to CsToCppPorter: none. Source C# Code namespace StatementsPorting { public class SomeClass { } public class VarExpressions { public void Expressions() { var value1 = 666; var value2 = 666U; var value3 = 666L; var value4 = 666LU; var value5 = 1.2345f; var value6 = 1.2345; var value7 = 'X'; var value8 = "iddqd"; var value9 = new SomeClass(); } } } Ported Code C++ Header #pragma once #include <system/object. Read More »

This example demonstrates how while statement is ported to C++. Additional command-line options passed to CsToCppPorter: none. Source C# Code using System; namespace StatementsPorting { public class WhileStatements { public void While(int max) { int number = 0; while (number < max) { Console.WriteLine(number); ++number; } } public void EnclosedWhile(int max1, int max2) { int number1 = 0; while (number1 < max1) { int number2 = 0; while (number2 < max2) { Console. Read More »