C# for C++ Programmers: Key Differences and New Features

© 2007 Compass Point, Inc.
9434 SW 55th Avenue  Portland OR 97219  Phone: 503.329.1138  info@compass-point.net
www.compass-point.net
1
C# for C++ Programmers

2
How C# Looks

3
using genericCar;
namespace Toyota;
{
public class Camry : Car
{
private static Camry camry;
private Brake brake;
public void main()
{
camry = new Camry();
camry.getBrake().ToString();
}
public Camry()
{
this.brake = new Brake();
}
public override Brake getBrake()
{
return this.brake;
}
}
}
C# Console Application Project

4
using System.IO;
namespace Toyota
{
public class Brake
{
string brakeName;
public Brake()
{
this.brakeName = “Brake 1”;
}
public override string ToString()
{
System.Console.Out.Writeln(“I’m ” + this.brakeName);
}
}
}
Namespace GenericCar
Class Car
Public MustOverride Sub getBrake()
End Class
C# Class Library Project
Vb.net Class Library Project

5
Differences between C# and C++

6
Pointers
• Can be used in C# , but only in code blocks, methods, or classes
marked with the unsafe keyword.
• Primarily used for accessing Win32 functions that use pointers.
class MyClass
{
unsafe int *pX;
unsafe int MethodThatUsesPointers()
{ //can use pointers
}
int Method()
{
unsafe
{ //can use pointers
}
}
}

7
References, Classes, and Structs
• References
– are used in C#, which are effectively opaque pointers that don’t
allow the aspects of pointer functionality that can cause bugs.
• Classes and structs
– are different in C#:
– structs are value types, stored on the stack, and cannot inherit,
– classes always reference types stored on the managed heap
and are always derivatives of System.Object.

8
Accessing native code
• C# code can only access native code through PInvoke.
class PInvoke
{
[DllImport("user32.dll")]
public static extern int MessageBoxA( int h, string m, string c, int type);
public static int Main()
{
return MessageBoxA(0, "Hello World!", "My Message Box", 0);
}
}

9
Destruction
• Destruction
– Same syntax as for C++, but don’t need to declare it as virtual
and shouldn’t add an access modifier.
– C# cannot guarantee when a destructor will be called – called by
the garbage collector.
– Can force cleanup: System.GC.Collect();
– For deterministic destruction, classes should implement
IDisposable.Dispose()
– C# supports special syntax that mimics C++ classes that are
instantiated on the stack where the destructor is called when it
goes out of scope:
using (MyClassThatHasDestructor mc = new MyClassThatHasDestructor)
{
//code that uses mc
} // mc.Dispose() implicitly called when leaving block.

10
Miscellaneous
• Binary PE format
– C# compiler will only generate managed assemblies – no native
code.
• Operator Overloading
– C# can overload operators, but not as many. Not commonly
used.
• Preprocessor
– C# has preprocessor directives, similar to C++ but far fewer. No
separate preprocessor – compiler does preprocessing.
– C# doesn’t need #include – no need to declare compiler symbols
used in code but not yet defined.

11
Miscellaneous
• C# doesn’t require a semicolon after a class
• C# doesn’t support class objects on the stack.
• const only at compile time, readonly set once at
runtime in constructor.
• C# has no function pointers – delegates instead.

12
C# New Features

13
Delegates
delegate void AnOperation(int x);
class AClass
{
void AMethod(int i)
{
System.Console.WriteLine(“Number is ” + i.ToString());
}
static int Main(string[] args)
{
AClass aClass = new AClass();
AnOperation anOperation = new AnOperation(AClass.AMethod);
anOperation(4);
}
}
stdio console output:
Number is 4
– When delegate returns a void, is a ‘multicast’ delegate and can represent more than one
method. += and -= can be used to add and remove a method from a multicast delegate.

14
Events
• An event source EventSourceClass declares an event
with this special syntax:
public delegate void EventClass(obj Sender, EventArgs e);
public event EventClass SourceEvent;
• Client event handlers must look like this:
void MyEventCallback(object sender, EventArgs e)
{
//handle event
}
• Client event handlers are added to an event source like
this:
EventSourceClass.SourceEvent += MyEventCallback;
• An event source then invokes the event like this:
SourceEvent(this, new EventArgs());

15
Attributes and Properties
• Attributes
– meta info that can be accessed at runtime
[WebMethod]
public ShippingPreference[] GetShippingPreferences(ShoppingCart
shoppingCart, CustomerInformation customerInformation)
{
}
• Properties
class ContainsProperty
{
private int age;
public int Age
{
get { return age;}
set { age = value;}
}
}

16
Exceptions
• Exceptions in C# support a finally block:
try
{
//normal execution path
}
catch (Exception ex)
{
//execution jumps to here if Exception or derivative
//is thrown in try block.
}
finally
{
//ALWAYS executes, either after try or catch clause executes.
}

17
Miscellaneous
• Interfaces
• Threading
lock() statement (shortcut for System.Threading.Monitor)
• Boxing
– Value types are primitives.
– Value types can be treated as objects
– Even literal types can be treated as objects.
string age = 42.ToString();
int i = 20;
object o = i;

C++ features unsupported in C#
18
• No templates – generics instead (C++/CLI has both)
• No multiple inheritance for base classes.

19
Configuration

20
XML File Based
• .NET assemblies use XML-based configuration
files named ExecutableName.exe.config
• Registry is not commonly used for .NET
applications.

21
File Format
• ExecutableName.exe.config looks like:
<configuration>
<system.runtime.remoting>
<application>
<channels>
<channel ref="tcp" port="9091" />
</channels>
</application>
</system.runtime.remoting>
<appSettings>


<add key = "Service.isService" value = "false" />
<add key = "Service.eventsourcestring" value = "CCLI Service" />
<add key = "Service.servicename" value = "CCLI Service" />
<add key = "ServiceAssemblyName" value = "Framework" />
<add key = "ServiceClassNameConsole" value = "StarPraise.Core.ConsoleBootstrapper" />
<add key = "ServiceClassNameService" value = "StarPraise.Core.ComponentController" />
<add key = "Service.strStarting" value = "Service starting..." />
<add key = "Service.strStopping" value = "Service Stopping..." />

<add key = "Logger.loggerAssembly" value = "Framework" />
<add key = "Logger.loggerclassname" value = "StarPraise.Core.DefaultLogger" />
…
</configuration>

Accessing Configuration Values
22
static protected Logger getInstance()
{
if (Logger.loggerInstance == null)
{
try
{
ObjectHandle obj = Activator.CreateInstance(
System.Configuration.ConfigurationManager.AppSettings[Logger.loggerAssembly],
System.Configuration.ConfigurationManager.AppSettings[Logger.loggerclassname]);
Logger.loggerInstance = (Logger) obj.Unwrap();
Logger.loggerInstance.Start();
}
catch (Exception ex)
{
throw new RuntimeException(ex.ToString(), new
ComponentIdentity("Logger"), "getInstance");
}
}

23
Application Types

24
Types
There are five primary application
(‘executable’) projects in Visual Studio:
• Console Applications
• Services
• Forms Applications
• Web Applications
• Web Services

25
Form Applications
• VS.NET creates Main and adds to the form
application project.
• Windows Message Pump is encapsulated
entirely within classes contained in
System.Windows.
• System.Windows.Forms.Form is type
automatically created by VS.NET for forms
application projects.

26
Forms Applications
using System;
using System.Collections.Generic;
using System.Windows.Forms;
namespace
CompassPoint.ECommerce.OrderProcessingServ
ices
{
static class Program
{
/// <summary>
/// The main entry point for the
application.
/// </summary>
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefa
ult(false);
Application.Run(new
OrderProcessingWebServiceTest());
}
}
}
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace
CompassPoint.ECommerce.OrderProcessingServices
{
public partial class
OrderProcessingWebServiceTest : Form
{
public OrderProcessingWebServiceTest()
{
InitializeComponent();
}
}
}

27
Web Applications
• They are hosted in IIS.
• A variety of compile options from compile when accessed to pre-compile
including partial compile in the creamy middle!
• When webpage.aspx is accessed,
– IIS delegates to the ASP.NET runtime which
• creates a runtime object model for the page,
• Reads the page
• Returns all markup to IIS to return to browser except
• Embedded runat=server marked code in the page which it
runs in the runtime object model environment and returns the
resulting markup.

28
Web Services
• When a webservice.asmx is accessed, the
same thing happens, but SOAP ‘method’
invocation requests are redirected to
methods in the web service marked with a
special attribute.

29
Web Services
[WebService(Namespace = "http://tempuri.org/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]
[ToolboxItem(false)]
public class OrderProcessingService : System.Web.Services.WebService,
IOrderManager
{
[WebMethod]
public ShippingPreference[] GetShippingPreferences(ShoppingCart
shoppingCart, CustomerInformation customerInformation)
{
….

30
Web Application and Service
Configuration
• As for applications, configuration is stored in an
XML file.
• XML file is of same format as for other types of
applications.
• For both, the file is named web.config.

31
Discussion

C# for C++ Programmers: Key Differences and New Features

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (16)

Similar to C# for C++ Programmers: Key Differences and New Features

Similar to C# for C++ Programmers: Key Differences and New Features (20)

Recently uploaded

Recently uploaded (20)

C# for C++ Programmers: Key Differences and New Features